// and intersection types are further deconstructed on the target side, we don't want to

// make the check again (as it might fail for a partial target type). Therefore we obtain

// the regular source type and proceed with that.

}

let saveErrorInfo = errorInfo;

regularType.constructSignatures = (<ResolvedType>type).constructSignatures;

regularType.stringIndexType = (<ResolvedType>type).stringIndexType;

regularType.numberIndexType = (<ResolvedType>type).numberIndexType;

}

return regularType;

}

}

function parseIdentifierName(): Identifier {

}

function isLiteralPropertyName(): boolean {

token === SyntaxKind.StringLiteral ||

token === SyntaxKind.NumericLiteral;

}

}

function isSimplePropertyName() {

}

function parseComputedPropertyName(): ComputedPropertyName {

case ParsingContext.HeritageClauses:

return isHeritageClause();

case ParsingContext.ImportOrExportSpecifiers:

case ParsingContext.JsxAttributes:

case ParsingContext.JsxChildren:

return true;

case ParsingContext.JSDocFunctionParameters:

function nextTokenIsIdentifierOrKeyword() {

nextToken();

}

function isHeritageClauseExtendsOrImplementsKeyword(): boolean {

// the code would be implicitly: "name.identifierOrKeyword; identifierNameOrKeyword".

// In the first case though, ASI will not take effect because there is not a

// line terminator after the identifier or keyword.

let matchesPattern = lookAhead(nextTokenIsIdentifierOrKeywordOnSameLine);

if (matchesPattern) {

}

}

return parsePropertyOrMethodSignature();

}

}

}

}

function nextTokenIsIdentifierOrKeywordOnSameLine() {

nextToken();

}

function nextTokenIsFunctionKeywordOnSameLine() {

function nextTokenIsIdentifierOrKeywordOrNumberOnSameLine() {

nextToken();

}

function isDeclaration(): boolean {

case SyntaxKind.ImportKeyword:

nextToken();

return token === SyntaxKind.StringLiteral || token === SyntaxKind.AsteriskToken ||

case SyntaxKind.ExportKeyword:

nextToken();

if (token === SyntaxKind.EqualsToken || token === SyntaxKind.AsteriskToken ||

// It is very important that we check this *after* checking indexers because

// the [ token can start an index signature or a computed property name

token === SyntaxKind.StringLiteral ||

token === SyntaxKind.NumericLiteral ||

token === SyntaxKind.AsteriskToken ||

return true;

}

}

export function parseJSDocTypeExpressionForTests(content: string, start: number, length: number) {