case SyntaxKind.ConstructSignature:

case SyntaxKind.IndexSignature:

case SyntaxKind.ConstructorType:

return ContainerFlags.IsContainer | ContainerFlags.IsControlFlowContainer | ContainerFlags.HasLocals | ContainerFlags.IsFunctionLike;

case SyntaxKind.FunctionExpression:

// By not creating a new block-scoped-container here, we ensure that both 'var x'

// and 'let x' go into the Function-container's locals, and we do get a collision

// conflict.

}

return ContainerFlags.None;

case SyntaxKind.JSDocFunctionType:

case SyntaxKind.JSDocTypedefTag:

case SyntaxKind.JSDocCallbackTag:

case SyntaxKind.TypeAliasDeclaration:

case SyntaxKind.MappedType:

// All the children of these container types are never visible through another

// Report error if function is not top level function declaration

if (blockScopeContainer.kind !== SyntaxKind.SourceFile &&

blockScopeContainer.kind !== SyntaxKind.ModuleDeclaration &&

// We check first if the name is inside class declaration or class expression; if so give explicit message

// otherwise report generic error message.

const errorSpan = getErrorSpanForNode(file, node);

updateStrictModeStatementList((node as SourceFile).statements);

return bindSourceFileIfExternalModule();

case SyntaxKind.Block:

return;

}

// falls through

// To avoid that we will give an error to users if they use arguments objects in arrow function so that they

// can explicitly bound arguments objects

if (symbol === argumentsSymbol) {

error(node, Diagnostics.arguments_cannot_be_referenced_in_property_initializers);

return errorType;

}

// do not return here so in case if lexical this is captured - it will be reflected in flags on NodeLinks

}

break;

case SyntaxKind.ComputedPropertyName:

error(node, Diagnostics.this_cannot_be_referenced_in_a_computed_property_name);

break;

if (isClassLike(container.parent)) {

const symbol = getSymbolOfNode(container.parent);

return getFlowTypeOfReference(node, type);

}

let diagnosticMessage;

const declarationName = idText(right);

&& !isOptionalPropertyDeclaration(valueDeclaration)

&& !(isAccessExpression(node) && isAccessExpression(node.expression))

&& !isBlockScopedNameDeclaredBeforeUse(valueDeclaration, right)

}

}

return !!findAncestor(node, node => {

switch (node.kind) {

case SyntaxKind.PropertyDeclaration:

case SyntaxKind.ExpressionWithTypeArguments:

case SyntaxKind.HeritageClause:

return false;

default:

return isExpressionNode(node) ? false : "quit";

}

function checkAwaitExpression(node: AwaitExpression): Type {

// Grammar checking

if (produceDiagnostics) {

if (isInTopLevelContext(node)) {

const sourceFile = getSourceFileOfNode(node);

if (!hasParseDiagnostics(sourceFile)) {

if (!hasParseDiagnostics(sourceFile)) {

const span = getSpanOfTokenAtPosition(sourceFile, node.pos);

const diagnostic = createFileDiagnostic(sourceFile, span.start, span.length, Diagnostics.await_expressions_are_only_allowed_within_async_functions_and_at_the_top_levels_of_modules);

addRelatedInfo(diagnostic, relatedInfo);

}

diagnostics.add(diagnostic);

}

}

function checkConstructorDeclaration(node: ConstructorDeclaration) {

// Grammar check on signature of constructor and modifier of the constructor is done in checkSignatureDeclaration function.

checkSignatureDeclaration(node);

break;

case SyntaxKind.IndexSignature:

case SyntaxKind.SemicolonClassElement:

// Can't be private

break;

default:

}

}

}

if (!node.name) {

return;

}

// For a computed property, just check the initializer and exit

// Do not use hasDynamicName here, because that returns false for well known symbols.

// We want to perform checkComputedPropertyName for all computed properties, including

function checkForOfStatement(node: ForOfStatement): void {

checkGrammarForInOrForOfStatement(node);

if (node.awaitModifier) {

}

}

else if (compilerOptions.downlevelIteration && languageVersion < ScriptTarget.ES2015) {

return;

}

grammarErrorOnFirstToken(node, Diagnostics.A_return_statement_can_only_be_used_within_a_function_body);

return;

}

const returnType = getReturnTypeOfSignature(signature);

if (strictNullChecks || node.expression || returnType.flags & TypeFlags.Never) {

const exprType = node.expression ? checkExpressionCached(node.expression) : undefinedType;

if (node.expression) {

error(node, Diagnostics.Setters_cannot_return_a_value);

}

}

if (node.expression && !checkTypeAssignableToAndOptionallyElaborate(exprType, returnType, node, node.expression)) {

error(node, Diagnostics.Return_type_of_constructor_signature_must_be_assignable_to_the_instance_type_of_the_class);

}

}

const unwrappedReturnType = unwrapReturnType(returnType, functionFlags) ?? returnType;

const unwrappedExprType = functionFlags & FunctionFlags.Async

? checkAwaitedType(exprType, node, Diagnostics.The_return_type_of_an_async_function_must_either_be_a_valid_promise_or_must_not_contain_a_callable_then_member)

}

}

}

// The function has a return type, but the return statement doesn't have an expression.

error(node, Diagnostics.Not_all_code_paths_return_a_value);

}

case SyntaxKind.MethodDeclaration:

case SyntaxKind.MethodSignature:

return checkMethodDeclaration(node as MethodDeclaration | MethodSignature);

case SyntaxKind.Constructor:

return checkConstructorDeclaration(node as ConstructorDeclaration);

case SyntaxKind.GetAccessor:

case SyntaxKind.InterfaceDeclaration:

case SyntaxKind.VariableStatement:

case SyntaxKind.TypeAliasDeclaration:

return true;

case SyntaxKind.EnumDeclaration:

return nodeHasAnyModifiersExcept(node, SyntaxKind.ConstKeyword);

function checkGrammarBreakOrContinueStatement(node: BreakOrContinueStatement): boolean {

let current: Node = node;

while (current) {

return grammarErrorOnNode(node, Diagnostics.Jump_target_cannot_cross_function_boundary);

}

"Class decorators can't be used with static private identifier. Consider removing the experimental decorator.": {

"category": "Error",

"code": 18036

}

}

return emitMethodSignature(node as MethodSignature);

case SyntaxKind.MethodDeclaration:

return emitMethodDeclaration(node as MethodDeclaration);

case SyntaxKind.Constructor:

return emitConstructor(node as ConstructorDeclaration);

case SyntaxKind.GetAccessor:

emitSignatureAndBody(node, emitSignatureHead);

}

function emitConstructor(node: ConstructorDeclaration) {

emitModifiers(node, node.modifiers);

writeKeyword("constructor");

updateConstructSignature,

createIndexSignature,

updateIndexSignature,

createTemplateLiteralTypeSpan,

updateTemplateLiteralTypeSpan,

createKeywordTypeNode,

: node;

}

// @api

function createConstructorDeclaration(

decorators: readonly Decorator[] | undefined,

return node.kind === SyntaxKind.MethodDeclaration;

}

export function isConstructorDeclaration(node: Node): node is ConstructorDeclaration {

return node.kind === SyntaxKind.Constructor;

}