export var syntaxDiagnosticsTime: number = 0;

export class SyntaxTree {

private _sourceUnit: SourceUnitSyntax;

private _isDeclaration: boolean;

private _parserDiagnostics: Diagnostic[];

private _allDiagnostics: Diagnostic[] = undefined;

private _fileName: string;

private _lineMap: LineMap;

private _languageVersion: ts.ScriptTarget;

// Computed on demand.

private _amdDependencies: string[];

private _isExternalModule: boolean;

constructor(sourceUnit: SourceUnitSyntax,

isDeclaration: boolean,

diagnostics: Diagnostic[],

fileName: string,

public text: ISimpleText,

languageVersion: ts.ScriptTarget) {

this._sourceUnit = sourceUnit;

this._isDeclaration = isDeclaration;

this._parserDiagnostics = diagnostics;

this._fileName = fileName;

this._lineMap = text.lineMap();

this._languageVersion = languageVersion;

sourceUnit.syntaxTree = this;

}

public sourceUnit(): SourceUnitSyntax {

return this._sourceUnit;

}

public isDeclaration(): boolean {

return this._isDeclaration;

}

private computeDiagnostics(): Diagnostic[] {

if (this._parserDiagnostics.length > 0) {

return this._parserDiagnostics;

}

// No parser reported diagnostics. Check for any additional grammar diagnostics.

var diagnostics: Diagnostic[] = [];

visitNodeOrToken(new GrammarCheckerWalker(this, diagnostics), this.sourceUnit());

return diagnostics;

}

public diagnostics(): Diagnostic[] {

if (!this._allDiagnostics) {

var start = new Date().getTime();

this._allDiagnostics = this.computeDiagnostics();

syntaxDiagnosticsTime += new Date().getTime() - start;

}

return this._allDiagnostics;

}

public fileName(): string {

return this._fileName;

}

public lineMap(): LineMap {

return this._lineMap;

}

public languageVersion(): ts.ScriptTarget {

return this._languageVersion;

}

private getAmdDependency(comment: string): string {

var amdDependencyRegEx = /^\/\/\/\s*<amd-dependency\s+path=('|")(.+?)\1/gim;

var match = amdDependencyRegEx.exec(comment);

return match ? match[2] : undefined;

}

}

class GrammarCheckerWalker extends SyntaxWalker {

private inAmbientDeclaration: boolean = false;

private inBlock: boolean = false;

private inObjectLiteralExpression: boolean = false;

private text: ISimpleText;

constructor(private syntaxTree: SyntaxTree,

private diagnostics: Diagnostic[]) {

super();

this.text = syntaxTree.text;

}

private pushDiagnostic(element: ISyntaxElement, diagnosticKey: string, args?: any[]): boolean {

return this.pushDiagnosticAt(start(element, this.text), width(element), diagnosticKey, args);

}

private pushDiagnosticAt(start: number, length: number, diagnosticKey: string, args?: any[]): boolean {

this.diagnostics.push(new Diagnostic(

this.syntaxTree.fileName(), this.syntaxTree.lineMap(), start, length, diagnosticKey, args));

return true;

}

public visitCallSignature(node: CallSignatureSyntax): void {

if (this.checkForCommaInsteadOfSemicolon(node.semicolonOrCommaToken)) {

return;

}

super.visitCallSignature(node);

}

public visitCatchClause(node: CatchClauseSyntax): void {

if (this.checkForCatchClauseTypeAnnotation(node) ||

this.checkForDisallowedEvalOrArguments(node, node.identifier)) {

return;

}

super.visitCatchClause(node);

}

private checkForCatchClauseTypeAnnotation(node: CatchClauseSyntax): boolean {

if (node.typeAnnotation) {

return this.pushDiagnostic(node.typeAnnotation.colonToken, DiagnosticCode.Catch_clause_parameter_cannot_have_a_type_annotation);

}

return false;

}

private checkParameterListOrder(node: ParameterListSyntax): boolean {

var seenOptionalParameter = false;

var parameterCount = nonSeparatorCount(node.parameters);

for (var i = 0; i < parameterCount; i++) {

var parameter = nonSeparatorAt(node.parameters, i);

if (parameter.dotDotDotToken) {

if (i !== (parameterCount - 1)) {

return this.pushDiagnostic(parameter, DiagnosticCode.A_rest_parameter_must_be_last_in_a_parameter_list);

}

if (parameter.questionToken) {

return this.pushDiagnostic(parameter, DiagnosticCode.A_rest_parameter_cannot_be_optional);

}

if (parameter.equalsValueClause) {

return this.pushDiagnostic(parameter, DiagnosticCode.A_rest_parameter_cannot_have_an_initializer);

}

}

else if (parameter.questionToken || parameter.equalsValueClause) {

seenOptionalParameter = true;

if (parameter.questionToken && parameter.equalsValueClause) {

return this.pushDiagnostic(parameter, DiagnosticCode.Parameter_cannot_have_question_mark_and_initializer);

}

}

else {

if (seenOptionalParameter) {

return this.pushDiagnostic(parameter, DiagnosticCode.A_required_parameter_cannot_follow_an_optional_parameter);

}

}

}

return false;

}

private checkParameterAccessibilityModifiers(parameter: ParameterSyntax): boolean {

if (parameter.modifiers.length > 0) {

var modifiers = parameter.modifiers;

for (var i = 0, n = modifiers.length; i < n; i++) {

var modifier = modifiers[i];

if (this.checkParameterAccessibilityModifier(modifier, i)) {

return true;

}

}

}

return false;

}

private checkParameterAccessibilityModifier(modifier: ISyntaxToken, modifierIndex: number): boolean {

if (!SyntaxFacts.isAccessibilityModifier(modifier.kind)) {

return this.pushDiagnostic(modifier, DiagnosticCode._0_modifier_cannot_appear_on_a_parameter, [modifier.text()]);

}

else {

if (modifierIndex > 0) {

return this.pushDiagnostic(modifier, DiagnosticCode.Accessibility_modifier_already_seen);

}

}

return false;

}

private checkForTrailingComma(list: ISyntaxNodeOrToken[]): boolean {

// If we have at least one child, and we have an even number of children, then that

// means we have an illegal trailing separator.

if (list.length === 0 || list.length % 2 === 1) {

return false;

}

var child = list[list.length - 1];

return this.pushDiagnostic(child, DiagnosticCode.Trailing_comma_not_allowed);

}

private checkForAtLeastOneElement(list: ISyntaxNodeOrToken[], reportToken: ISyntaxToken, listKind: string): boolean {

if (childCount(list) > 0) {

return false;

}

return this.pushDiagnostic(reportToken, DiagnosticCode._0_list_cannot_be_empty, [listKind]);

}

public visitParameterList(node: ParameterListSyntax): void {

if (this.checkParameterListOrder(node) ||

this.checkForTrailingComma(node.parameters)) {

return;

}

super.visitParameterList(node);

}

public visitHeritageClause(node: HeritageClauseSyntax): void {

if (this.checkForTrailingComma(node.typeNames) ||

this.checkForAtLeastOneElement(node.typeNames, node.extendsOrImplementsKeyword, SyntaxFacts.getText(node.extendsOrImplementsKeyword.kind))) {

return;

}

super.visitHeritageClause(node);

}

public visitArgumentList(node: ArgumentListSyntax): void {

if (this.checkForTrailingComma(node.arguments)) {

return;

}

super.visitArgumentList(node);

}

public visitVariableDeclaration(node: VariableDeclarationSyntax): void {

if (this.checkForAtLeastOneElement(node.variableDeclarators, node.varConstOrLetKeyword, getLocalizedText(DiagnosticCode.variable_declaration, undefined)) ||

this.checkForTrailingComma(node.variableDeclarators)) {

return;

}

super.visitVariableDeclaration(node);

}

public visitTypeAlias(node: TypeAliasSyntax): void {

if (node.modifiers.length > 0) {

this.pushDiagnostic(node.modifiers[0], DiagnosticCode.Modifiers_cannot_appear_here);

return;

}

super.visitTypeAlias(node);

}

public visitTypeArgumentList(node: TypeArgumentListSyntax): void {

if (this.checkForTrailingComma(node.typeArguments) ||

this.checkForAtLeastOneElement(node.typeArguments, node.lessThanToken, getLocalizedText(DiagnosticCode.type_argument, undefined))) {

return;

}

super.visitTypeArgumentList(node);

}

public visitTupleType(node: TupleTypeSyntax): void {

if (this.checkForTrailingComma(node.types) ||

this.checkForAtLeastOneElement(node.types, node.openBracketToken, getLocalizedText(DiagnosticCode.type, undefined))) {

return

}

super.visitTupleType(node);

}

public visitTypeParameterList(node: TypeParameterListSyntax): void {

if (this.checkForTrailingComma(node.typeParameters) ||

this.checkForAtLeastOneElement(node.typeParameters, node.lessThanToken, getLocalizedText(DiagnosticCode.type_parameter, undefined))) {

return;

}

super.visitTypeParameterList(node);

}

private checkIndexSignatureParameter(node: IndexSignatureSyntax): boolean {

if (node.parameters.length !== 1) {

return this.pushDiagnostic(node.openBracketToken, DiagnosticCode.Index_signature_must_have_exactly_one_parameter);

}

var parameter = nonSeparatorAt(node.parameters, 0);

if (parameter.dotDotDotToken) {

return this.pushDiagnostic(parameter, DiagnosticCode.Index_signatures_cannot_have_rest_parameters);

}

else if (parameter.modifiers.length > 0) {

return this.pushDiagnostic(parameter, DiagnosticCode.Index_signature_parameter_cannot_have_modifiers);

}

else if (parameter.questionToken) {

return this.pushDiagnostic(parameter, DiagnosticCode.Index_signature_parameter_cannot_have_a_question_mark);

}

else if (parameter.equalsValueClause) {

return this.pushDiagnostic(parameter, DiagnosticCode.Index_signature_parameter_cannot_have_an_initializer);

}

else if (!parameter.typeAnnotation) {

return this.pushDiagnostic(parameter, DiagnosticCode.Index_signature_parameter_must_have_a_type_annotation);

}

else if (parameter.typeAnnotation.type.kind !== SyntaxKind.StringKeyword &&

parameter.typeAnnotation.type.kind !== SyntaxKind.NumberKeyword) {

return this.pushDiagnostic(parameter, DiagnosticCode.Index_signature_parameter_type_must_be_string_or_number);

}

return false;

}

private checkForCommaInsteadOfSemicolon(commaOrSemicolon: ISyntaxToken) {

if (commaOrSemicolon && commaOrSemicolon.kind === SyntaxKind.CommaToken) {

return this.pushDiagnostic(commaOrSemicolon, DiagnosticCode._0_expected, [SyntaxFacts.getText(SyntaxKind.SemicolonToken)]);

}

return false;

}

public visitIndexSignature(node: IndexSignatureSyntax): void {

if (this.checkIndexSignatureParameter(node) ||

this.checkForCommaInsteadOfSemicolon(node.semicolonOrCommaToken) ||

this.checkIndexSignatureModifiers(node)) {

return;

}

if (!node.typeAnnotation) {

this.pushDiagnostic(node, DiagnosticCode.Index_signature_must_have_a_type_annotation);

return;

}

super.visitIndexSignature(node);

}

private checkClassDeclarationHeritageClauses(node: ClassDeclarationSyntax): boolean {

var seenExtendsClause = false;

var seenImplementsClause = false;

for (var i = 0, n = node.heritageClauses.length; i < n; i++) {

Debug.assert(i <= 2);

var heritageClause = node.heritageClauses[i];

if (heritageClause.extendsOrImplementsKeyword.kind === SyntaxKind.ExtendsKeyword) {

if (seenExtendsClause) {

return this.pushDiagnostic(heritageClause, DiagnosticCode.extends_clause_already_seen);

}

if (seenImplementsClause) {

return this.pushDiagnostic(heritageClause, DiagnosticCode.extends_clause_must_precede_implements_clause);

}

if (nonSeparatorCount(heritageClause.typeNames) > 1) {

return this.pushDiagnostic(heritageClause, DiagnosticCode.Classes_can_only_extend_a_single_class);

}

seenExtendsClause = true;

}

else {

Debug.assert(heritageClause.extendsOrImplementsKeyword.kind === SyntaxKind.ImplementsKeyword);

if (seenImplementsClause) {

return this.pushDiagnostic(heritageClause, DiagnosticCode.implements_clause_already_seen);

}

seenImplementsClause = true;

}

}

return false;

}

private checkForDisallowedDeclareModifier(modifiers: ISyntaxToken[]): boolean {

if (this.inAmbientDeclaration) {

// If we're already in an ambient declaration, then 'declare' is not allowed.

var declareToken = SyntaxUtilities.getToken(modifiers, SyntaxKind.DeclareKeyword);

if (declareToken) {

return this.pushDiagnostic(declareToken, DiagnosticCode.A_declare_modifier_cannot_be_used_in_an_already_ambient_context);

}

}

return false;

}

private checkForRequiredDeclareModifier(moduleElement: IModuleElementSyntax, reportToken: ISyntaxToken, modifiers: ISyntaxToken[]): boolean {

if (!this.inAmbientDeclaration && this.syntaxTree.isDeclaration()) {

// We're at the top level in a declaration file, a 'declare' modifiers is required

// on most module elements.

if (!SyntaxUtilities.containsToken(modifiers, SyntaxKind.DeclareKeyword)) {

return this.pushDiagnostic(reportToken, DiagnosticCode.A_declare_modifier_is_required_for_a_top_level_declaration_in_a_d_ts_file);

}

}

}

public visitClassDeclaration(node: ClassDeclarationSyntax): void {

if (this.checkForDisallowedDeclareModifier(node.modifiers) ||

this.checkForRequiredDeclareModifier(node, node.identifier, node.modifiers) ||

this.checkModuleElementModifiers(node.modifiers) ||

this.checkClassDeclarationHeritageClauses(node) ||

this.checkForDisallowedAsyncModifier(node.modifiers)) {

return;

}

var savedInAmbientDeclaration = this.inAmbientDeclaration;

this.inAmbientDeclaration = this.inAmbientDeclaration || this.syntaxTree.isDeclaration() || SyntaxUtilities.containsToken(node.modifiers, SyntaxKind.DeclareKeyword);

super.visitClassDeclaration(node);

this.inAmbientDeclaration = savedInAmbientDeclaration;

}

private checkInterfaceDeclarationHeritageClauses(node: InterfaceDeclarationSyntax): boolean {

var seenExtendsClause = false;

for (var i = 0, n = node.heritageClauses.length; i < n; i++) {

Debug.assert(i <= 1);

var heritageClause = node.heritageClauses[i];

if (heritageClause.extendsOrImplementsKeyword.kind === SyntaxKind.ExtendsKeyword) {

if (seenExtendsClause) {

return this.pushDiagnostic(heritageClause, DiagnosticCode.extends_clause_already_seen);

}

seenExtendsClause = true;

}

else {

Debug.assert(heritageClause.extendsOrImplementsKeyword.kind === SyntaxKind.ImplementsKeyword);

return this.pushDiagnostic(heritageClause, DiagnosticCode.Interface_declaration_cannot_have_implements_clause);

}

}

return false;

}

private checkInterfaceModifiers(modifiers: ISyntaxToken[]): boolean {

for (var i = 0, n = modifiers.length; i < n; i++) {

var modifier = modifiers[i];

if (modifier.kind === SyntaxKind.DeclareKeyword) {

return this.pushDiagnostic(modifier, DiagnosticCode.A_declare_modifier_cannot_be_used_with_an_interface_declaration);

}

}

return false;

}

public visitInterfaceDeclaration(node: InterfaceDeclarationSyntax): void {

if (this.checkInterfaceModifiers(node.modifiers) ||

this.checkModuleElementModifiers(node.modifiers) ||

this.checkInterfaceDeclarationHeritageClauses(node) ||

this.checkForDisallowedAsyncModifier(node.modifiers)) {

return;

}

super.visitInterfaceDeclaration(node);

}

private checkClassElementModifiers(list: ISyntaxToken[]): boolean {

var seenAccessibilityModifier = false;

var seenStaticModifier = false;

var seenAsyncModifier = false;

for (var i = 0, n = list.length; i < n; i++) {

var modifier = list[i];

if (SyntaxFacts.isAccessibilityModifier(modifier.kind)) {

if (seenAccessibilityModifier) {

return this.pushDiagnostic(modifier, DiagnosticCode.Accessibility_modifier_already_seen);

}

if (seenStaticModifier) {

return this.pushDiagnostic(modifier, DiagnosticCode._0_modifier_must_precede_1_modifier, [modifier.text(), list[i - 1].text()]);

}

if (seenAsyncModifier) {

return this.pushDiagnostic(modifier, DiagnosticCode._0_modifier_must_precede_1_modifier, [modifier.text(), SyntaxFacts.getText(SyntaxKind.AsyncKeyword)]);

}

seenAccessibilityModifier = true;

}

else if (modifier.kind === SyntaxKind.StaticKeyword) {

if (seenStaticModifier) {

return this.pushDiagnostic(modifier, DiagnosticCode._0_modifier_already_seen, [modifier.text()]);

}

if (seenAsyncModifier) {

return this.pushDiagnostic(modifier, DiagnosticCode._0_modifier_must_precede_1_modifier, [modifier.text(), SyntaxFacts.getText(SyntaxKind.AsyncKeyword)]);

}

seenStaticModifier = true;

}

else if (modifier.kind === SyntaxKind.AsyncKeyword) {

if (seenAsyncModifier) {

return this.pushDiagnostic(modifier, DiagnosticCode._0_modifier_already_seen, [modifier.text()]);

}

seenAsyncModifier = true;

}

else {

return this.pushDiagnostic(modifier, DiagnosticCode._0_modifier_cannot_appear_on_a_class_element, [modifier.text()]);

}

}

return false;

}

public visitPropertyDeclaration(node: PropertyDeclarationSyntax): void {

if (this.checkClassElementModifiers(node.modifiers) ||

this.checkForDisallowedAsyncModifier(node.modifiers)) {

return;

}

super.visitPropertyDeclaration(node);

}

public visitMethodSignature(node: MethodSignatureSyntax): void {

if (this.checkForDisallowedTemplatePropertyName(node.propertyName) ||

this.checkForDisallowedComputedPropertyName(node.propertyName)) {

return;

}

super.visitMethodSignature(node);

}

public visitPropertySignature(node: PropertySignatureSyntax): void {

if (this.checkForDisallowedTemplatePropertyName(node.propertyName) ||

this.checkForDisallowedComputedPropertyName(node.propertyName) ||

this.checkForCommaInsteadOfSemicolon(node.semicolonOrCommaToken)) {

return;

}

super.visitPropertySignature(node);

}

public visitMethodDeclaration(node: MethodDeclarationSyntax): void {

if (node.parent && node.parent.parent &&

node.parent.kind === SyntaxKind.List && node.parent.parent.kind === SyntaxKind.ObjectLiteralExpression) {

// Method in an object literal.

if (this.checkForSemicolonInsteadOfBlock(node, node.body) ||

this.checkForDisallowedObjectLiteralMethod(node.modifiers)) {

return;

}

}

else {

// Method in a class literal.

if (this.checkClassElementModifiers(node.modifiers)) {

return;

}

}

// Object literal or class method.

if (this.checkForDisallowedTemplatePropertyName(node.propertyName) ||

this.checkForAsyncGenerator(this.getAsyncModifier(node.modifiers), node.asterixToken)) {

return;

}

super.visitMethodDeclaration(node);

}

private checkForDisallowedObjectLiteralMethod(modifiers: ISyntaxToken[]): boolean {

for (var i = 0, n = modifiers.length; i < n; i++) {

var modifier = modifiers[i];

if (modifier.kind !== SyntaxKind.AsyncKeyword) {

return this.pushDiagnostic(modifier, DiagnosticCode.Modifiers_cannot_appear_here);

}

}

return false;

}

private checkGetAccessorParameter(node: GetAccessorSyntax): boolean {

if (node.callSignature.parameterList.parameters.length !== 0) {

return this.pushDiagnostic(node.propertyName, DiagnosticCode.get_accessor_cannot_have_parameters);

}

return false;

}

private checkIndexSignatureModifiers(node: IndexSignatureSyntax): boolean {

if (node.modifiers.length > 0) {

return this.pushDiagnostic(node.modifiers[0], DiagnosticCode.Modifiers_cannot_appear_here);

}

return false;

}

private checkEcmaScriptVersionIsAtLeast(reportToken: ISyntaxToken, languageVersion: ts.ScriptTarget, diagnosticKey: string): boolean {

if (this.syntaxTree.languageVersion() < languageVersion) {

return this.pushDiagnostic(reportToken, diagnosticKey);

}

return false;

}

public visitObjectLiteralExpression(node: ObjectLiteralExpressionSyntax): void {

var savedInObjectLiteralExpression = this.inObjectLiteralExpression;

this.inObjectLiteralExpression = true;

super.visitObjectLiteralExpression(node);

this.inObjectLiteralExpression = savedInObjectLiteralExpression;

}

public visitGetAccessor(node: GetAccessorSyntax): void {

if (this.checkForAccessorDeclarationInAmbientContext(node) ||

this.checkEcmaScriptVersionIsAtLeast(node.getKeyword, ts.ScriptTarget.ES5, DiagnosticCode.Accessors_are_only_available_when_targeting_ECMAScript_5_and_higher) ||

this.checkForDisallowedModifiersInBlockOrObjectLitera(node.modifiers) ||

this.checkClassElementModifiers(node.modifiers) ||

this.checkForDisallowedAccessorTypeParameters(node.callSignature) ||

this.checkGetAccessorParameter(node) ||

this.checkForDisallowedTemplatePropertyName(node.propertyName) ||

this.checkForSemicolonInsteadOfBlock(node, node.body) ||

this.checkForDisallowedAsyncModifier(node.modifiers)) {

return;

}

super.visitGetAccessor(node);

}

private checkForSemicolonInsteadOfBlock(parent: ISyntaxNode, node: BlockSyntax | ExpressionBody | ISyntaxToken): boolean {

if (node === undefined) {

return this.pushDiagnosticAt(fullEnd(parent), 0, DiagnosticCode._0_expected, ["{"]);

}

else if (node.kind === SyntaxKind.SemicolonToken) {

return this.pushDiagnostic(node, DiagnosticCode._0_expected, ["{"]);

}

return false;

}

private checkForDisallowedSetAccessorTypeAnnotation(accessor: SetAccessorSyntax): boolean {

if (accessor.callSignature.typeAnnotation) {

return this.pushDiagnostic(accessor.callSignature.typeAnnotation, DiagnosticCode.Type_annotation_cannot_appear_on_a_set_accessor);

}

return false;

}

private checkForDisallowedAccessorTypeParameters(callSignature: CallSignatureSyntax): boolean {

if (callSignature.typeParameterList) {

return this.pushDiagnostic(callSignature.typeParameterList, DiagnosticCode.Type_parameters_cannot_appear_on_an_accessor);

}

return false;

}

private checkForAccessorDeclarationInAmbientContext(accessor: ISyntaxNode): boolean {

if (this.inAmbientDeclaration) {

return this.pushDiagnostic(accessor, DiagnosticCode.Accessors_are_not_allowed_in_ambient_contexts);

}

return false;

}

private checkSetAccessorParameter(node: SetAccessorSyntax): boolean {

var parameters = node.callSignature.parameterList.parameters;

if (nonSeparatorCount(parameters) !== 1) {

return this.pushDiagnostic(node.propertyName, DiagnosticCode.set_accessor_must_have_exactly_one_parameter);

}

var parameter = nonSeparatorAt(parameters, 0);

if (parameter.questionToken) {

return this.pushDiagnostic(parameter, DiagnosticCode.set_accessor_parameter_cannot_be_optional);

}

if (parameter.equalsValueClause) {

return this.pushDiagnostic(parameter, DiagnosticCode.set_accessor_parameter_cannot_have_an_initializer);

}

if (parameter.dotDotDotToken) {

return this.pushDiagnostic(parameter, DiagnosticCode.set_accessor_cannot_have_rest_parameter);

}

return false;

}

public visitSimpleArrowFunctionExpression(node: SimpleArrowFunctionExpressionSyntax): void {

if (node.asyncKeyword) {

this.pushDiagnostic(node.asyncKeyword, DiagnosticCode.async_arrow_function_parameters_must_be_parenthesized);

return;

}

super.visitSimpleArrowFunctionExpression(node);

}

public visitPropertyAssignment(node: PropertyAssignmentSyntax): void {

if (this.checkForDisallowedTemplatePropertyName(node.propertyName)) {

return;

}

super.visitPropertyAssignment(node);

}

public visitSetAccessor(node: SetAccessorSyntax): void {

if (this.checkForAccessorDeclarationInAmbientContext(node) ||

this.checkEcmaScriptVersionIsAtLeast(node.setKeyword, ts.ScriptTarget.ES5, DiagnosticCode.Accessors_are_only_available_when_targeting_ECMAScript_5_and_higher) ||

this.checkForDisallowedModifiersInBlockOrObjectLitera(node.modifiers) ||

this.checkClassElementModifiers(node.modifiers) ||

this.checkForDisallowedAccessorTypeParameters(node.callSignature) ||

this.checkForDisallowedSetAccessorTypeAnnotation(node) ||

this.checkSetAccessorParameter(node) ||

this.checkForDisallowedTemplatePropertyName(node.propertyName) ||

this.checkForSemicolonInsteadOfBlock(node, node.body) ||

this.checkForDisallowedAsyncModifier(node.modifiers)) {

return;

}

super.visitSetAccessor(node);

}

private checkForDisallowedAsyncModifier(modifiers: ISyntaxToken[]) {

var asyncKeyword = this.getAsyncModifier(modifiers);

if (asyncKeyword) {

return this.pushDiagnostic(asyncKeyword, DiagnosticCode.async_modifier_cannot_appear_here);

}

return false;

}

public visitElementAccessExpression(node: ElementAccessExpressionSyntax): void {

if (this.checkForMissingArgumentExpression(node)) {

return;

}

super.visitElementAccessExpression(node);

}

public checkForMissingArgumentExpression(node: ElementAccessExpressionSyntax): boolean {

if (node.argumentExpression === undefined) {

if (node.parent.kind === SyntaxKind.ObjectCreationExpression && (<ObjectCreationExpressionSyntax>node.parent).expression === node) {

// Provide a specialized message for the very common case where someone writes:

// new Foo[]

var start = TypeScript.start(node.openBracketToken);

var end = TypeScript.fullEnd(node.closeBracketToken);

return this.pushDiagnosticAt(start, end - start, DiagnosticCode.new_T_cannot_be_used_to_create_an_array_Use_new_Array_T_instead);

}

else {

return this.pushDiagnostic(node.closeBracketToken, DiagnosticCode.Expression_expected);

}

}

return false;

}

public visitEnumDeclaration(node: EnumDeclarationSyntax): void {

if (this.checkForDisallowedDeclareModifier(node.modifiers) ||

this.checkForRequiredDeclareModifier(node, node.identifier, node.modifiers) ||

this.checkModuleElementModifiers(node.modifiers),

this.checkEnumElements(node) ||

this.checkForDisallowedAsyncModifier(node.modifiers)) {

return;

}

var savedInAmbientDeclaration = this.inAmbientDeclaration;

this.inAmbientDeclaration = this.inAmbientDeclaration || this.syntaxTree.isDeclaration() || SyntaxUtilities.containsToken(node.modifiers, SyntaxKind.DeclareKeyword);

super.visitEnumDeclaration(node);

this.inAmbientDeclaration = savedInAmbientDeclaration;

}