diff --git a/Jakefile b/Jakefile index c1c408af0e9..15661debff6 100644 --- a/Jakefile +++ b/Jakefile @@ -58,6 +58,7 @@ var servicesSources = [ "checker.ts", "emitter.ts", "program.ts", + "commandLineParser.ts", "diagnosticInformationMap.generated.ts" ].map(function (f) { return path.join(compilerDirectory, f); @@ -102,6 +103,7 @@ var internalDefinitionsRoots = [ "compiler/core.d.ts", "compiler/sys.d.ts", "compiler/utilities.d.ts", + "compiler/commandLineParser.d.ts", "services/utilities.d.ts", ]; diff --git a/bin/tsc.js b/bin/tsc.js index b547abd2469..070f5356189 100644 --- a/bin/tsc.js +++ b/bin/tsc.js @@ -212,6 +212,12 @@ var ts; return result; } ts.mapToArray = mapToArray; + function copyMap(source, target) { + for (var p in source) { + target[p] = source[p]; + } + } + ts.copyMap = copyMap; function arrayToMap(array, makeKey) { var result = {}; forEach(array, function (value) { @@ -1219,7 +1225,7 @@ var ts; Unsupported_locale_0: { code: 6049, category: 1 /* Error */, key: "Unsupported locale '{0}'." }, Unable_to_open_file_0: { code: 6050, category: 1 /* Error */, key: "Unable to open file '{0}'." }, Corrupted_locale_file_0: { code: 6051, category: 1 /* Error */, key: "Corrupted locale file {0}." }, - Warn_on_expressions_and_declarations_with_an_implied_any_type: { code: 6052, category: 2 /* Message */, key: "Warn on expressions and declarations with an implied 'any' type." }, + Raise_error_on_expressions_and_declarations_with_an_implied_any_type: { code: 6052, category: 2 /* Message */, key: "Warn on expressions and declarations with an implied 'any' type." }, File_0_not_found: { code: 6053, category: 1 /* Error */, key: "File '{0}' not found." }, File_0_must_have_extension_ts_or_d_ts: { code: 6054, category: 1 /* Error */, key: "File '{0}' must have extension '.ts' or '.d.ts'." }, Suppress_noImplicitAny_errors_for_indexing_objects_lacking_index_signatures: { code: 6055, category: 2 /* Message */, key: "Suppress noImplicitAny errors for indexing objects lacking index signatures." }, @@ -2790,6 +2796,11 @@ var ts; return false; } ts.isExpression = isExpression; + function isInstantiatedModule(node, preserveConstEnums) { + var moduleState = ts.getModuleInstanceState(node); + return moduleState === 1 /* Instantiated */ || (preserveConstEnums && moduleState === 2 /* ConstEnumOnly */); + } + ts.isInstantiatedModule = isInstantiatedModule; function isExternalModuleImportDeclaration(node) { return node.kind === 197 /* ImportDeclaration */ && node.moduleReference.kind === 199 /* ExternalModuleReference */; } @@ -3180,34 +3191,37 @@ var ts; return new (getNodeConstructor(kind))(); } ts.createNode = createNode; - function forEachChild(node, cbNode, cbNodes) { - function child(node) { - if (node) { - return cbNode(node); - } + function visitNode(cbNode, node) { + if (node) { + return cbNode(node); } - function children(nodes) { - if (nodes) { - if (cbNodes) { - return cbNodes(nodes); - } - for (var i = 0, len = nodes.length; i < len; i++) { - var result = cbNode(nodes[i]); - if (result) { - return result; - } + } + function visitNodeArray(cbNodes, nodes) { + if (nodes) { + return cbNodes(nodes); + } + } + function visitEachNode(cbNode, nodes) { + if (nodes) { + for (var i = 0, len = nodes.length; i < len; i++) { + var result = cbNode(nodes[i]); + if (result) { + return result; } - return undefined; } } + } + function forEachChild(node, cbNode, cbNodeArray) { if (!node) { return; } + var visitNodes = cbNodeArray ? visitNodeArray : visitEachNode; + var cbNodes = cbNodeArray || cbNode; switch (node.kind) { case 121 /* QualifiedName */: - return child(node.left) || child(node.right); + return visitNode(cbNode, node.left) || visitNode(cbNode, node.right); case 123 /* TypeParameter */: - return child(node.name) || child(node.constraint) || child(node.expression); + return visitNode(cbNode, node.name) || visitNode(cbNode, node.constraint) || visitNode(cbNode, node.expression); case 124 /* Parameter */: case 126 /* PropertyDeclaration */: case 125 /* PropertySignature */: @@ -3215,13 +3229,13 @@ var ts; case 205 /* ShorthandPropertyAssignment */: case 188 /* VariableDeclaration */: case 146 /* BindingElement */: - return children(node.modifiers) || child(node.propertyName) || child(node.dotDotDotToken) || child(node.name) || child(node.questionToken) || child(node.type) || child(node.initializer); + return visitNodes(cbNodes, node.modifiers) || visitNode(cbNode, node.propertyName) || visitNode(cbNode, node.dotDotDotToken) || visitNode(cbNode, node.name) || visitNode(cbNode, node.questionToken) || visitNode(cbNode, node.type) || visitNode(cbNode, node.initializer); case 136 /* FunctionType */: case 137 /* ConstructorType */: case 132 /* CallSignature */: case 133 /* ConstructSignature */: case 134 /* IndexSignature */: - return children(node.modifiers) || children(node.typeParameters) || children(node.parameters) || child(node.type); + return visitNodes(cbNodes, node.modifiers) || visitNodes(cbNodes, node.typeParameters) || visitNodes(cbNodes, node.parameters) || visitNode(cbNode, node.type); case 128 /* MethodDeclaration */: case 127 /* MethodSignature */: case 129 /* Constructor */: @@ -3230,127 +3244,127 @@ var ts; case 156 /* FunctionExpression */: case 190 /* FunctionDeclaration */: case 157 /* ArrowFunction */: - return children(node.modifiers) || child(node.asteriskToken) || child(node.name) || child(node.questionToken) || children(node.typeParameters) || children(node.parameters) || child(node.type) || child(node.body); + return visitNodes(cbNodes, node.modifiers) || visitNode(cbNode, node.asteriskToken) || visitNode(cbNode, node.name) || visitNode(cbNode, node.questionToken) || visitNodes(cbNodes, node.typeParameters) || visitNodes(cbNodes, node.parameters) || visitNode(cbNode, node.type) || visitNode(cbNode, node.body); case 135 /* TypeReference */: - return child(node.typeName) || children(node.typeArguments); + return visitNode(cbNode, node.typeName) || visitNodes(cbNodes, node.typeArguments); case 138 /* TypeQuery */: - return child(node.exprName); + return visitNode(cbNode, node.exprName); case 139 /* TypeLiteral */: - return children(node.members); + return visitNodes(cbNodes, node.members); case 140 /* ArrayType */: - return child(node.elementType); + return visitNode(cbNode, node.elementType); case 141 /* TupleType */: - return children(node.elementTypes); + return visitNodes(cbNodes, node.elementTypes); case 142 /* UnionType */: - return children(node.types); + return visitNodes(cbNodes, node.types); case 143 /* ParenthesizedType */: - return child(node.type); + return visitNode(cbNode, node.type); case 144 /* ObjectBindingPattern */: case 145 /* ArrayBindingPattern */: - return children(node.elements); + return visitNodes(cbNodes, node.elements); case 147 /* ArrayLiteralExpression */: - return children(node.elements); + return visitNodes(cbNodes, node.elements); case 148 /* ObjectLiteralExpression */: - return children(node.properties); + return visitNodes(cbNodes, node.properties); case 149 /* PropertyAccessExpression */: - return child(node.expression) || child(node.name); + return visitNode(cbNode, node.expression) || visitNode(cbNode, node.name); case 150 /* ElementAccessExpression */: - return child(node.expression) || child(node.argumentExpression); + return visitNode(cbNode, node.expression) || visitNode(cbNode, node.argumentExpression); case 151 /* CallExpression */: case 152 /* NewExpression */: - return child(node.expression) || children(node.typeArguments) || children(node.arguments); + return visitNode(cbNode, node.expression) || visitNodes(cbNodes, node.typeArguments) || visitNodes(cbNodes, node.arguments); case 153 /* TaggedTemplateExpression */: - return child(node.tag) || child(node.template); + return visitNode(cbNode, node.tag) || visitNode(cbNode, node.template); case 154 /* TypeAssertionExpression */: - return child(node.type) || child(node.expression); + return visitNode(cbNode, node.type) || visitNode(cbNode, node.expression); case 155 /* ParenthesizedExpression */: - return child(node.expression); + return visitNode(cbNode, node.expression); case 158 /* DeleteExpression */: - return child(node.expression); + return visitNode(cbNode, node.expression); case 159 /* TypeOfExpression */: - return child(node.expression); + return visitNode(cbNode, node.expression); case 160 /* VoidExpression */: - return child(node.expression); + return visitNode(cbNode, node.expression); case 161 /* PrefixUnaryExpression */: - return child(node.operand); + return visitNode(cbNode, node.operand); case 166 /* YieldExpression */: - return child(node.asteriskToken) || child(node.expression); + return visitNode(cbNode, node.asteriskToken) || visitNode(cbNode, node.expression); case 162 /* PostfixUnaryExpression */: - return child(node.operand); + return visitNode(cbNode, node.operand); case 163 /* BinaryExpression */: - return child(node.left) || child(node.right); + return visitNode(cbNode, node.left) || visitNode(cbNode, node.right); case 164 /* ConditionalExpression */: - return child(node.condition) || child(node.whenTrue) || child(node.whenFalse); + return visitNode(cbNode, node.condition) || visitNode(cbNode, node.whenTrue) || visitNode(cbNode, node.whenFalse); case 167 /* SpreadElementExpression */: - return child(node.expression); + return visitNode(cbNode, node.expression); case 170 /* Block */: case 196 /* ModuleBlock */: - return children(node.statements); + return visitNodes(cbNodes, node.statements); case 207 /* SourceFile */: - return children(node.statements) || child(node.endOfFileToken); + return visitNodes(cbNodes, node.statements) || visitNode(cbNode, node.endOfFileToken); case 171 /* VariableStatement */: - return children(node.modifiers) || child(node.declarationList); + return visitNodes(cbNodes, node.modifiers) || visitNode(cbNode, node.declarationList); case 189 /* VariableDeclarationList */: - return children(node.declarations); + return visitNodes(cbNodes, node.declarations); case 173 /* ExpressionStatement */: - return child(node.expression); + return visitNode(cbNode, node.expression); case 174 /* IfStatement */: - return child(node.expression) || child(node.thenStatement) || child(node.elseStatement); + return visitNode(cbNode, node.expression) || visitNode(cbNode, node.thenStatement) || visitNode(cbNode, node.elseStatement); case 175 /* DoStatement */: - return child(node.statement) || child(node.expression); + return visitNode(cbNode, node.statement) || visitNode(cbNode, node.expression); case 176 /* WhileStatement */: - return child(node.expression) || child(node.statement); + return visitNode(cbNode, node.expression) || visitNode(cbNode, node.statement); case 177 /* ForStatement */: - return child(node.initializer) || child(node.condition) || child(node.iterator) || child(node.statement); + return visitNode(cbNode, node.initializer) || visitNode(cbNode, node.condition) || visitNode(cbNode, node.iterator) || visitNode(cbNode, node.statement); case 178 /* ForInStatement */: - return child(node.initializer) || child(node.expression) || child(node.statement); + return visitNode(cbNode, node.initializer) || visitNode(cbNode, node.expression) || visitNode(cbNode, node.statement); case 179 /* ContinueStatement */: case 180 /* BreakStatement */: - return child(node.label); + return visitNode(cbNode, node.label); case 181 /* ReturnStatement */: - return child(node.expression); + return visitNode(cbNode, node.expression); case 182 /* WithStatement */: - return child(node.expression) || child(node.statement); + return visitNode(cbNode, node.expression) || visitNode(cbNode, node.statement); case 183 /* SwitchStatement */: - return child(node.expression) || children(node.clauses); + return visitNode(cbNode, node.expression) || visitNodes(cbNodes, node.clauses); case 200 /* CaseClause */: - return child(node.expression) || children(node.statements); + return visitNode(cbNode, node.expression) || visitNodes(cbNodes, node.statements); case 201 /* DefaultClause */: - return children(node.statements); + return visitNodes(cbNodes, node.statements); case 184 /* LabeledStatement */: - return child(node.label) || child(node.statement); + return visitNode(cbNode, node.label) || visitNode(cbNode, node.statement); case 185 /* ThrowStatement */: - return child(node.expression); + return visitNode(cbNode, node.expression); case 186 /* TryStatement */: - return child(node.tryBlock) || child(node.catchClause) || child(node.finallyBlock); + return visitNode(cbNode, node.tryBlock) || visitNode(cbNode, node.catchClause) || visitNode(cbNode, node.finallyBlock); case 203 /* CatchClause */: - return child(node.name) || child(node.type) || child(node.block); + return visitNode(cbNode, node.name) || visitNode(cbNode, node.type) || visitNode(cbNode, node.block); case 191 /* ClassDeclaration */: - return children(node.modifiers) || child(node.name) || children(node.typeParameters) || children(node.heritageClauses) || children(node.members); + return visitNodes(cbNodes, node.modifiers) || visitNode(cbNode, node.name) || visitNodes(cbNodes, node.typeParameters) || visitNodes(cbNodes, node.heritageClauses) || visitNodes(cbNodes, node.members); case 192 /* InterfaceDeclaration */: - return children(node.modifiers) || child(node.name) || children(node.typeParameters) || children(node.heritageClauses) || children(node.members); + return visitNodes(cbNodes, node.modifiers) || visitNode(cbNode, node.name) || visitNodes(cbNodes, node.typeParameters) || visitNodes(cbNodes, node.heritageClauses) || visitNodes(cbNodes, node.members); case 193 /* TypeAliasDeclaration */: - return children(node.modifiers) || child(node.name) || child(node.type); + return visitNodes(cbNodes, node.modifiers) || visitNode(cbNode, node.name) || visitNode(cbNode, node.type); case 194 /* EnumDeclaration */: - return children(node.modifiers) || child(node.name) || children(node.members); + return visitNodes(cbNodes, node.modifiers) || visitNode(cbNode, node.name) || visitNodes(cbNodes, node.members); case 206 /* EnumMember */: - return child(node.name) || child(node.initializer); + return visitNode(cbNode, node.name) || visitNode(cbNode, node.initializer); case 195 /* ModuleDeclaration */: - return children(node.modifiers) || child(node.name) || child(node.body); + return visitNodes(cbNodes, node.modifiers) || visitNode(cbNode, node.name) || visitNode(cbNode, node.body); case 197 /* ImportDeclaration */: - return children(node.modifiers) || child(node.name) || child(node.moduleReference); + return visitNodes(cbNodes, node.modifiers) || visitNode(cbNode, node.name) || visitNode(cbNode, node.moduleReference); case 198 /* ExportAssignment */: - return children(node.modifiers) || child(node.exportName); + return visitNodes(cbNodes, node.modifiers) || visitNode(cbNode, node.exportName); case 165 /* TemplateExpression */: - return child(node.head) || children(node.templateSpans); + return visitNode(cbNode, node.head) || visitNodes(cbNodes, node.templateSpans); case 169 /* TemplateSpan */: - return child(node.expression) || child(node.literal); + return visitNode(cbNode, node.expression) || visitNode(cbNode, node.literal); case 122 /* ComputedPropertyName */: - return child(node.expression); + return visitNode(cbNode, node.expression); case 202 /* HeritageClause */: - return children(node.types); + return visitNodes(cbNodes, node.types); case 199 /* ExternalModuleReference */: - return child(node.expression); + return visitNode(cbNode, node.expression); } } ts.forEachChild = forEachChild; @@ -7980,7 +7994,6 @@ var ts; case 134 /* IndexSignature */: case 124 /* Parameter */: case 196 /* ModuleBlock */: - case 123 /* TypeParameter */: case 136 /* FunctionType */: case 137 /* ConstructorType */: case 139 /* TypeLiteral */: @@ -7990,6 +8003,7 @@ var ts; case 142 /* UnionType */: case 143 /* ParenthesizedType */: return isDeclarationVisible(node.parent); + case 123 /* TypeParameter */: case 207 /* SourceFile */: return true; default: @@ -9745,9 +9759,7 @@ var ts; if (result) { var maybeCache = maybeStack[depth]; var destinationCache = result === -1 /* True */ || depth === 0 ? relation : maybeStack[depth - 1]; - for (var p in maybeCache) { - destinationCache[p] = maybeCache[p]; - } + ts.copyMap(maybeCache, destinationCache); } else { relation[id] = false; @@ -10566,7 +10578,7 @@ var ts; } function getNarrowedTypeOfSymbol(symbol, node) { var type = getTypeOfSymbol(symbol); - if (node && symbol.flags & 3 /* Variable */ && type.flags & (48128 /* ObjectType */ | 16384 /* Union */ | 512 /* TypeParameter */)) { + if (node && symbol.flags & 3 /* Variable */ && type.flags & (1 /* Any */ | 48128 /* ObjectType */ | 16384 /* Union */ | 512 /* TypeParameter */)) { loop: while (node.parent) { var child = node; node = node.parent; @@ -10655,7 +10667,7 @@ var ts; } } function narrowTypeByInstanceof(type, expr, assumeTrue) { - if (!assumeTrue || expr.left.kind !== 64 /* Identifier */ || getResolvedSymbol(expr.left) !== symbol) { + if (type.flags & 1 /* Any */ || !assumeTrue || expr.left.kind !== 64 /* Identifier */ || getResolvedSymbol(expr.left) !== symbol) { return type; } var rightType = checkExpression(expr.right); @@ -13789,7 +13801,7 @@ var ts; checkCollisionWithRequireExportsInGeneratedCode(node, node.name); checkExportsOnMergedDeclarations(node); var symbol = getSymbolOfNode(node); - if (symbol.flags & 512 /* ValueModule */ && symbol.declarations.length > 1 && !ts.isInAmbientContext(node)) { + if (symbol.flags & 512 /* ValueModule */ && symbol.declarations.length > 1 && !ts.isInAmbientContext(node) && ts.isInstantiatedModule(node, compilerOptions.preserveConstEnums)) { var classOrFunc = getFirstNonAmbientClassOrFunctionDeclaration(symbol); if (classOrFunc) { if (ts.getSourceFileOfNode(node) !== ts.getSourceFileOfNode(classOrFunc)) { @@ -16894,19 +16906,30 @@ var ts; if (emitOuterParens) { write("("); } - emitLiteral(node.head); - ts.forEach(node.templateSpans, function (templateSpan) { + var headEmitted = false; + if (shouldEmitTemplateHead()) { + emitLiteral(node.head); + headEmitted = true; + } + for (var i = 0; i < node.templateSpans.length; i++) { + var templateSpan = node.templateSpans[i]; var needsParens = templateSpan.expression.kind !== 155 /* ParenthesizedExpression */ && comparePrecedenceToBinaryPlus(templateSpan.expression) !== 1 /* GreaterThan */; - write(" + "); + if (i > 0 || headEmitted) { + write(" + "); + } emitParenthesized(templateSpan.expression, needsParens); if (templateSpan.literal.text.length !== 0) { write(" + "); emitLiteral(templateSpan.literal); } - }); + } if (emitOuterParens) { write(")"); } + function shouldEmitTemplateHead() { + ts.Debug.assert(node.templateSpans.length !== 0); + return node.head.text.length !== 0 || node.templateSpans[0].literal.text.length === 0; + } function templateNeedsParens(template, parent) { switch (parent.kind) { case 151 /* CallExpression */: @@ -16930,6 +16953,7 @@ var ts; case 37 /* PercentToken */: return 1 /* GreaterThan */; case 33 /* PlusToken */: + case 34 /* MinusToken */: return 0 /* EqualTo */; default: return -1 /* LessThan */; @@ -18313,7 +18337,7 @@ var ts; } } function emitModuleDeclaration(node) { - var shouldEmit = ts.getModuleInstanceState(node) === 1 /* Instantiated */ || (ts.getModuleInstanceState(node) === 2 /* ConstEnumOnly */ && compilerOptions.preserveConstEnums); + var shouldEmit = ts.isInstantiatedModule(node, compilerOptions.preserveConstEnums); if (!shouldEmit) { return emitPinnedOrTripleSlashComments(node); } @@ -19033,7 +19057,10 @@ var ts; } } else { - if (!(findSourceFile(filename + ".ts", isDefaultLib, refFile, refPos, refEnd) || findSourceFile(filename + ".d.ts", isDefaultLib, refFile, refPos, refEnd))) { + if (options.allowNonTsExtensions && !findSourceFile(filename, isDefaultLib, refFile, refPos, refEnd)) { + diagnostic = ts.Diagnostics.File_0_not_found; + } + else if (!findSourceFile(filename + ".ts", isDefaultLib, refFile, refPos, refEnd) && !findSourceFile(filename + ".d.ts", isDefaultLib, refFile, refPos, refEnd)) { diagnostic = ts.Diagnostics.File_0_not_found; filename += ".ts"; } @@ -19268,7 +19295,7 @@ var ts; { name: "noImplicitAny", type: "boolean", - description: ts.Diagnostics.Warn_on_expressions_and_declarations_with_an_implied_any_type + description: ts.Diagnostics.Raise_error_on_expressions_and_declarations_with_an_implied_any_type }, { name: "noLib", diff --git a/bin/typescript.d.ts b/bin/typescript.d.ts index bd7764c3f4b..592b73ba8d9 100644 --- a/bin/typescript.d.ts +++ b/bin/typescript.d.ts @@ -1028,8 +1028,6 @@ declare module "typescript" { } interface GenericType extends InterfaceType, TypeReference { instantiations: Map; - openReferenceTargets: GenericType[]; - openReferenceChecks: Map; } interface TupleType extends ObjectType { elementTypes: Type[]; @@ -1370,7 +1368,7 @@ declare module "typescript" { declare module "typescript" { function getNodeConstructor(kind: SyntaxKind): new () => Node; function createNode(kind: SyntaxKind): Node; - function forEachChild(node: Node, cbNode: (node: Node) => T, cbNodes?: (nodes: Node[]) => T): T; + function forEachChild(node: Node, cbNode: (node: Node) => T, cbNodeArray?: (nodes: Node[]) => T): T; function modifierToFlag(token: SyntaxKind): NodeFlags; function isEvalOrArgumentsIdentifier(node: Node): boolean; function createSourceFile(filename: string, sourceText: string, languageVersion: ScriptTarget, setParentNodes?: boolean): SourceFile; diff --git a/bin/typescriptServices.d.ts b/bin/typescriptServices.d.ts index c980d9c2d69..6fd1cda359a 100644 --- a/bin/typescriptServices.d.ts +++ b/bin/typescriptServices.d.ts @@ -1028,8 +1028,6 @@ declare module ts { } interface GenericType extends InterfaceType, TypeReference { instantiations: Map; - openReferenceTargets: GenericType[]; - openReferenceChecks: Map; } interface TupleType extends ObjectType { elementTypes: Type[]; @@ -1370,7 +1368,7 @@ declare module ts { declare module ts { function getNodeConstructor(kind: SyntaxKind): new () => Node; function createNode(kind: SyntaxKind): Node; - function forEachChild(node: Node, cbNode: (node: Node) => T, cbNodes?: (nodes: Node[]) => T): T; + function forEachChild(node: Node, cbNode: (node: Node) => T, cbNodeArray?: (nodes: Node[]) => T): T; function modifierToFlag(token: SyntaxKind): NodeFlags; function isEvalOrArgumentsIdentifier(node: Node): boolean; function createSourceFile(filename: string, sourceText: string, languageVersion: ScriptTarget, setParentNodes?: boolean): SourceFile; diff --git a/bin/typescriptServices.js b/bin/typescriptServices.js index 9506ab39dcf..c3725bdc367 100644 --- a/bin/typescriptServices.js +++ b/bin/typescriptServices.js @@ -763,6 +763,12 @@ var ts; return result; } ts.mapToArray = mapToArray; + function copyMap(source, target) { + for (var p in source) { + target[p] = source[p]; + } + } + ts.copyMap = copyMap; function arrayToMap(array, makeKey) { var result = {}; forEach(array, function (value) { @@ -1777,7 +1783,7 @@ var ts; Unsupported_locale_0: { code: 6049, category: 1 /* Error */, key: "Unsupported locale '{0}'." }, Unable_to_open_file_0: { code: 6050, category: 1 /* Error */, key: "Unable to open file '{0}'." }, Corrupted_locale_file_0: { code: 6051, category: 1 /* Error */, key: "Corrupted locale file {0}." }, - Warn_on_expressions_and_declarations_with_an_implied_any_type: { code: 6052, category: 2 /* Message */, key: "Warn on expressions and declarations with an implied 'any' type." }, + Raise_error_on_expressions_and_declarations_with_an_implied_any_type: { code: 6052, category: 2 /* Message */, key: "Warn on expressions and declarations with an implied 'any' type." }, File_0_not_found: { code: 6053, category: 1 /* Error */, key: "File '{0}' not found." }, File_0_must_have_extension_ts_or_d_ts: { code: 6054, category: 1 /* Error */, key: "File '{0}' must have extension '.ts' or '.d.ts'." }, Suppress_noImplicitAny_errors_for_indexing_objects_lacking_index_signatures: { code: 6055, category: 2 /* Message */, key: "Suppress noImplicitAny errors for indexing objects lacking index signatures." }, @@ -3348,6 +3354,11 @@ var ts; return false; } ts.isExpression = isExpression; + function isInstantiatedModule(node, preserveConstEnums) { + var moduleState = ts.getModuleInstanceState(node); + return moduleState === 1 /* Instantiated */ || (preserveConstEnums && moduleState === 2 /* ConstEnumOnly */); + } + ts.isInstantiatedModule = isInstantiatedModule; function isExternalModuleImportDeclaration(node) { return node.kind === 197 /* ImportDeclaration */ && node.moduleReference.kind === 199 /* ExternalModuleReference */; } @@ -3738,34 +3749,37 @@ var ts; return new (getNodeConstructor(kind))(); } ts.createNode = createNode; - function forEachChild(node, cbNode, cbNodes) { - function child(node) { - if (node) { - return cbNode(node); - } + function visitNode(cbNode, node) { + if (node) { + return cbNode(node); } - function children(nodes) { - if (nodes) { - if (cbNodes) { - return cbNodes(nodes); - } - for (var i = 0, len = nodes.length; i < len; i++) { - var result = cbNode(nodes[i]); - if (result) { - return result; - } + } + function visitNodeArray(cbNodes, nodes) { + if (nodes) { + return cbNodes(nodes); + } + } + function visitEachNode(cbNode, nodes) { + if (nodes) { + for (var i = 0, len = nodes.length; i < len; i++) { + var result = cbNode(nodes[i]); + if (result) { + return result; } - return undefined; } } + } + function forEachChild(node, cbNode, cbNodeArray) { if (!node) { return; } + var visitNodes = cbNodeArray ? visitNodeArray : visitEachNode; + var cbNodes = cbNodeArray || cbNode; switch (node.kind) { case 121 /* QualifiedName */: - return child(node.left) || child(node.right); + return visitNode(cbNode, node.left) || visitNode(cbNode, node.right); case 123 /* TypeParameter */: - return child(node.name) || child(node.constraint) || child(node.expression); + return visitNode(cbNode, node.name) || visitNode(cbNode, node.constraint) || visitNode(cbNode, node.expression); case 124 /* Parameter */: case 126 /* PropertyDeclaration */: case 125 /* PropertySignature */: @@ -3773,13 +3787,13 @@ var ts; case 205 /* ShorthandPropertyAssignment */: case 188 /* VariableDeclaration */: case 146 /* BindingElement */: - return children(node.modifiers) || child(node.propertyName) || child(node.dotDotDotToken) || child(node.name) || child(node.questionToken) || child(node.type) || child(node.initializer); + return visitNodes(cbNodes, node.modifiers) || visitNode(cbNode, node.propertyName) || visitNode(cbNode, node.dotDotDotToken) || visitNode(cbNode, node.name) || visitNode(cbNode, node.questionToken) || visitNode(cbNode, node.type) || visitNode(cbNode, node.initializer); case 136 /* FunctionType */: case 137 /* ConstructorType */: case 132 /* CallSignature */: case 133 /* ConstructSignature */: case 134 /* IndexSignature */: - return children(node.modifiers) || children(node.typeParameters) || children(node.parameters) || child(node.type); + return visitNodes(cbNodes, node.modifiers) || visitNodes(cbNodes, node.typeParameters) || visitNodes(cbNodes, node.parameters) || visitNode(cbNode, node.type); case 128 /* MethodDeclaration */: case 127 /* MethodSignature */: case 129 /* Constructor */: @@ -3788,127 +3802,127 @@ var ts; case 156 /* FunctionExpression */: case 190 /* FunctionDeclaration */: case 157 /* ArrowFunction */: - return children(node.modifiers) || child(node.asteriskToken) || child(node.name) || child(node.questionToken) || children(node.typeParameters) || children(node.parameters) || child(node.type) || child(node.body); + return visitNodes(cbNodes, node.modifiers) || visitNode(cbNode, node.asteriskToken) || visitNode(cbNode, node.name) || visitNode(cbNode, node.questionToken) || visitNodes(cbNodes, node.typeParameters) || visitNodes(cbNodes, node.parameters) || visitNode(cbNode, node.type) || visitNode(cbNode, node.body); case 135 /* TypeReference */: - return child(node.typeName) || children(node.typeArguments); + return visitNode(cbNode, node.typeName) || visitNodes(cbNodes, node.typeArguments); case 138 /* TypeQuery */: - return child(node.exprName); + return visitNode(cbNode, node.exprName); case 139 /* TypeLiteral */: - return children(node.members); + return visitNodes(cbNodes, node.members); case 140 /* ArrayType */: - return child(node.elementType); + return visitNode(cbNode, node.elementType); case 141 /* TupleType */: - return children(node.elementTypes); + return visitNodes(cbNodes, node.elementTypes); case 142 /* UnionType */: - return children(node.types); + return visitNodes(cbNodes, node.types); case 143 /* ParenthesizedType */: - return child(node.type); + return visitNode(cbNode, node.type); case 144 /* ObjectBindingPattern */: case 145 /* ArrayBindingPattern */: - return children(node.elements); + return visitNodes(cbNodes, node.elements); case 147 /* ArrayLiteralExpression */: - return children(node.elements); + return visitNodes(cbNodes, node.elements); case 148 /* ObjectLiteralExpression */: - return children(node.properties); + return visitNodes(cbNodes, node.properties); case 149 /* PropertyAccessExpression */: - return child(node.expression) || child(node.name); + return visitNode(cbNode, node.expression) || visitNode(cbNode, node.name); case 150 /* ElementAccessExpression */: - return child(node.expression) || child(node.argumentExpression); + return visitNode(cbNode, node.expression) || visitNode(cbNode, node.argumentExpression); case 151 /* CallExpression */: case 152 /* NewExpression */: - return child(node.expression) || children(node.typeArguments) || children(node.arguments); + return visitNode(cbNode, node.expression) || visitNodes(cbNodes, node.typeArguments) || visitNodes(cbNodes, node.arguments); case 153 /* TaggedTemplateExpression */: - return child(node.tag) || child(node.template); + return visitNode(cbNode, node.tag) || visitNode(cbNode, node.template); case 154 /* TypeAssertionExpression */: - return child(node.type) || child(node.expression); + return visitNode(cbNode, node.type) || visitNode(cbNode, node.expression); case 155 /* ParenthesizedExpression */: - return child(node.expression); + return visitNode(cbNode, node.expression); case 158 /* DeleteExpression */: - return child(node.expression); + return visitNode(cbNode, node.expression); case 159 /* TypeOfExpression */: - return child(node.expression); + return visitNode(cbNode, node.expression); case 160 /* VoidExpression */: - return child(node.expression); + return visitNode(cbNode, node.expression); case 161 /* PrefixUnaryExpression */: - return child(node.operand); + return visitNode(cbNode, node.operand); case 166 /* YieldExpression */: - return child(node.asteriskToken) || child(node.expression); + return visitNode(cbNode, node.asteriskToken) || visitNode(cbNode, node.expression); case 162 /* PostfixUnaryExpression */: - return child(node.operand); + return visitNode(cbNode, node.operand); case 163 /* BinaryExpression */: - return child(node.left) || child(node.right); + return visitNode(cbNode, node.left) || visitNode(cbNode, node.right); case 164 /* ConditionalExpression */: - return child(node.condition) || child(node.whenTrue) || child(node.whenFalse); + return visitNode(cbNode, node.condition) || visitNode(cbNode, node.whenTrue) || visitNode(cbNode, node.whenFalse); case 167 /* SpreadElementExpression */: - return child(node.expression); + return visitNode(cbNode, node.expression); case 170 /* Block */: case 196 /* ModuleBlock */: - return children(node.statements); + return visitNodes(cbNodes, node.statements); case 207 /* SourceFile */: - return children(node.statements) || child(node.endOfFileToken); + return visitNodes(cbNodes, node.statements) || visitNode(cbNode, node.endOfFileToken); case 171 /* VariableStatement */: - return children(node.modifiers) || child(node.declarationList); + return visitNodes(cbNodes, node.modifiers) || visitNode(cbNode, node.declarationList); case 189 /* VariableDeclarationList */: - return children(node.declarations); + return visitNodes(cbNodes, node.declarations); case 173 /* ExpressionStatement */: - return child(node.expression); + return visitNode(cbNode, node.expression); case 174 /* IfStatement */: - return child(node.expression) || child(node.thenStatement) || child(node.elseStatement); + return visitNode(cbNode, node.expression) || visitNode(cbNode, node.thenStatement) || visitNode(cbNode, node.elseStatement); case 175 /* DoStatement */: - return child(node.statement) || child(node.expression); + return visitNode(cbNode, node.statement) || visitNode(cbNode, node.expression); case 176 /* WhileStatement */: - return child(node.expression) || child(node.statement); + return visitNode(cbNode, node.expression) || visitNode(cbNode, node.statement); case 177 /* ForStatement */: - return child(node.initializer) || child(node.condition) || child(node.iterator) || child(node.statement); + return visitNode(cbNode, node.initializer) || visitNode(cbNode, node.condition) || visitNode(cbNode, node.iterator) || visitNode(cbNode, node.statement); case 178 /* ForInStatement */: - return child(node.initializer) || child(node.expression) || child(node.statement); + return visitNode(cbNode, node.initializer) || visitNode(cbNode, node.expression) || visitNode(cbNode, node.statement); case 179 /* ContinueStatement */: case 180 /* BreakStatement */: - return child(node.label); + return visitNode(cbNode, node.label); case 181 /* ReturnStatement */: - return child(node.expression); + return visitNode(cbNode, node.expression); case 182 /* WithStatement */: - return child(node.expression) || child(node.statement); + return visitNode(cbNode, node.expression) || visitNode(cbNode, node.statement); case 183 /* SwitchStatement */: - return child(node.expression) || children(node.clauses); + return visitNode(cbNode, node.expression) || visitNodes(cbNodes, node.clauses); case 200 /* CaseClause */: - return child(node.expression) || children(node.statements); + return visitNode(cbNode, node.expression) || visitNodes(cbNodes, node.statements); case 201 /* DefaultClause */: - return children(node.statements); + return visitNodes(cbNodes, node.statements); case 184 /* LabeledStatement */: - return child(node.label) || child(node.statement); + return visitNode(cbNode, node.label) || visitNode(cbNode, node.statement); case 185 /* ThrowStatement */: - return child(node.expression); + return visitNode(cbNode, node.expression); case 186 /* TryStatement */: - return child(node.tryBlock) || child(node.catchClause) || child(node.finallyBlock); + return visitNode(cbNode, node.tryBlock) || visitNode(cbNode, node.catchClause) || visitNode(cbNode, node.finallyBlock); case 203 /* CatchClause */: - return child(node.name) || child(node.type) || child(node.block); + return visitNode(cbNode, node.name) || visitNode(cbNode, node.type) || visitNode(cbNode, node.block); case 191 /* ClassDeclaration */: - return children(node.modifiers) || child(node.name) || children(node.typeParameters) || children(node.heritageClauses) || children(node.members); + return visitNodes(cbNodes, node.modifiers) || visitNode(cbNode, node.name) || visitNodes(cbNodes, node.typeParameters) || visitNodes(cbNodes, node.heritageClauses) || visitNodes(cbNodes, node.members); case 192 /* InterfaceDeclaration */: - return children(node.modifiers) || child(node.name) || children(node.typeParameters) || children(node.heritageClauses) || children(node.members); + return visitNodes(cbNodes, node.modifiers) || visitNode(cbNode, node.name) || visitNodes(cbNodes, node.typeParameters) || visitNodes(cbNodes, node.heritageClauses) || visitNodes(cbNodes, node.members); case 193 /* TypeAliasDeclaration */: - return children(node.modifiers) || child(node.name) || child(node.type); + return visitNodes(cbNodes, node.modifiers) || visitNode(cbNode, node.name) || visitNode(cbNode, node.type); case 194 /* EnumDeclaration */: - return children(node.modifiers) || child(node.name) || children(node.members); + return visitNodes(cbNodes, node.modifiers) || visitNode(cbNode, node.name) || visitNodes(cbNodes, node.members); case 206 /* EnumMember */: - return child(node.name) || child(node.initializer); + return visitNode(cbNode, node.name) || visitNode(cbNode, node.initializer); case 195 /* ModuleDeclaration */: - return children(node.modifiers) || child(node.name) || child(node.body); + return visitNodes(cbNodes, node.modifiers) || visitNode(cbNode, node.name) || visitNode(cbNode, node.body); case 197 /* ImportDeclaration */: - return children(node.modifiers) || child(node.name) || child(node.moduleReference); + return visitNodes(cbNodes, node.modifiers) || visitNode(cbNode, node.name) || visitNode(cbNode, node.moduleReference); case 198 /* ExportAssignment */: - return children(node.modifiers) || child(node.exportName); + return visitNodes(cbNodes, node.modifiers) || visitNode(cbNode, node.exportName); case 165 /* TemplateExpression */: - return child(node.head) || children(node.templateSpans); + return visitNode(cbNode, node.head) || visitNodes(cbNodes, node.templateSpans); case 169 /* TemplateSpan */: - return child(node.expression) || child(node.literal); + return visitNode(cbNode, node.expression) || visitNode(cbNode, node.literal); case 122 /* ComputedPropertyName */: - return child(node.expression); + return visitNode(cbNode, node.expression); case 202 /* HeritageClause */: - return children(node.types); + return visitNodes(cbNodes, node.types); case 199 /* ExternalModuleReference */: - return child(node.expression); + return visitNode(cbNode, node.expression); } } ts.forEachChild = forEachChild; @@ -8578,7 +8592,6 @@ var ts; case 134 /* IndexSignature */: case 124 /* Parameter */: case 196 /* ModuleBlock */: - case 123 /* TypeParameter */: case 136 /* FunctionType */: case 137 /* ConstructorType */: case 139 /* TypeLiteral */: @@ -8588,6 +8601,7 @@ var ts; case 142 /* UnionType */: case 143 /* ParenthesizedType */: return isDeclarationVisible(node.parent); + case 123 /* TypeParameter */: case 207 /* SourceFile */: return true; default: @@ -10343,9 +10357,7 @@ var ts; if (result) { var maybeCache = maybeStack[depth]; var destinationCache = result === -1 /* True */ || depth === 0 ? relation : maybeStack[depth - 1]; - for (var p in maybeCache) { - destinationCache[p] = maybeCache[p]; - } + ts.copyMap(maybeCache, destinationCache); } else { relation[id] = false; @@ -11164,7 +11176,7 @@ var ts; } function getNarrowedTypeOfSymbol(symbol, node) { var type = getTypeOfSymbol(symbol); - if (node && symbol.flags & 3 /* Variable */ && type.flags & (48128 /* ObjectType */ | 16384 /* Union */ | 512 /* TypeParameter */)) { + if (node && symbol.flags & 3 /* Variable */ && type.flags & (1 /* Any */ | 48128 /* ObjectType */ | 16384 /* Union */ | 512 /* TypeParameter */)) { loop: while (node.parent) { var child = node; node = node.parent; @@ -11253,7 +11265,7 @@ var ts; } } function narrowTypeByInstanceof(type, expr, assumeTrue) { - if (!assumeTrue || expr.left.kind !== 64 /* Identifier */ || getResolvedSymbol(expr.left) !== symbol) { + if (type.flags & 1 /* Any */ || !assumeTrue || expr.left.kind !== 64 /* Identifier */ || getResolvedSymbol(expr.left) !== symbol) { return type; } var rightType = checkExpression(expr.right); @@ -14387,7 +14399,7 @@ var ts; checkCollisionWithRequireExportsInGeneratedCode(node, node.name); checkExportsOnMergedDeclarations(node); var symbol = getSymbolOfNode(node); - if (symbol.flags & 512 /* ValueModule */ && symbol.declarations.length > 1 && !ts.isInAmbientContext(node)) { + if (symbol.flags & 512 /* ValueModule */ && symbol.declarations.length > 1 && !ts.isInAmbientContext(node) && ts.isInstantiatedModule(node, compilerOptions.preserveConstEnums)) { var classOrFunc = getFirstNonAmbientClassOrFunctionDeclaration(symbol); if (classOrFunc) { if (ts.getSourceFileOfNode(node) !== ts.getSourceFileOfNode(classOrFunc)) { @@ -17492,19 +17504,30 @@ var ts; if (emitOuterParens) { write("("); } - emitLiteral(node.head); - ts.forEach(node.templateSpans, function (templateSpan) { + var headEmitted = false; + if (shouldEmitTemplateHead()) { + emitLiteral(node.head); + headEmitted = true; + } + for (var i = 0; i < node.templateSpans.length; i++) { + var templateSpan = node.templateSpans[i]; var needsParens = templateSpan.expression.kind !== 155 /* ParenthesizedExpression */ && comparePrecedenceToBinaryPlus(templateSpan.expression) !== 1 /* GreaterThan */; - write(" + "); + if (i > 0 || headEmitted) { + write(" + "); + } emitParenthesized(templateSpan.expression, needsParens); if (templateSpan.literal.text.length !== 0) { write(" + "); emitLiteral(templateSpan.literal); } - }); + } if (emitOuterParens) { write(")"); } + function shouldEmitTemplateHead() { + ts.Debug.assert(node.templateSpans.length !== 0); + return node.head.text.length !== 0 || node.templateSpans[0].literal.text.length === 0; + } function templateNeedsParens(template, parent) { switch (parent.kind) { case 151 /* CallExpression */: @@ -17528,6 +17551,7 @@ var ts; case 37 /* PercentToken */: return 1 /* GreaterThan */; case 33 /* PlusToken */: + case 34 /* MinusToken */: return 0 /* EqualTo */; default: return -1 /* LessThan */; @@ -18911,7 +18935,7 @@ var ts; } } function emitModuleDeclaration(node) { - var shouldEmit = ts.getModuleInstanceState(node) === 1 /* Instantiated */ || (ts.getModuleInstanceState(node) === 2 /* ConstEnumOnly */ && compilerOptions.preserveConstEnums); + var shouldEmit = ts.isInstantiatedModule(node, compilerOptions.preserveConstEnums); if (!shouldEmit) { return emitPinnedOrTripleSlashComments(node); } @@ -19631,7 +19655,10 @@ var ts; } } else { - if (!(findSourceFile(filename + ".ts", isDefaultLib, refFile, refPos, refEnd) || findSourceFile(filename + ".d.ts", isDefaultLib, refFile, refPos, refEnd))) { + if (options.allowNonTsExtensions && !findSourceFile(filename, isDefaultLib, refFile, refPos, refEnd)) { + diagnostic = ts.Diagnostics.File_0_not_found; + } + else if (!findSourceFile(filename + ".ts", isDefaultLib, refFile, refPos, refEnd) && !findSourceFile(filename + ".d.ts", isDefaultLib, refFile, refPos, refEnd)) { diagnostic = ts.Diagnostics.File_0_not_found; filename += ".ts"; } @@ -19802,6 +19829,249 @@ var ts; ts.createProgram = createProgram; })(ts || (ts = {})); var ts; +(function (ts) { + ts.optionDeclarations = [ + { + name: "charset", + type: "string" + }, + { + name: "codepage", + type: "number" + }, + { + name: "declaration", + shortName: "d", + type: "boolean", + description: ts.Diagnostics.Generates_corresponding_d_ts_file + }, + { + name: "diagnostics", + type: "boolean" + }, + { + name: "emitBOM", + type: "boolean" + }, + { + name: "help", + shortName: "h", + type: "boolean", + description: ts.Diagnostics.Print_this_message + }, + { + name: "locale", + type: "string" + }, + { + name: "mapRoot", + type: "string", + description: ts.Diagnostics.Specifies_the_location_where_debugger_should_locate_map_files_instead_of_generated_locations, + paramType: ts.Diagnostics.LOCATION + }, + { + name: "module", + shortName: "m", + type: { + "commonjs": 1 /* CommonJS */, + "amd": 2 /* AMD */ + }, + description: ts.Diagnostics.Specify_module_code_generation_Colon_commonjs_or_amd, + paramType: ts.Diagnostics.KIND, + error: ts.Diagnostics.Argument_for_module_option_must_be_commonjs_or_amd + }, + { + name: "noEmit", + type: "boolean", + description: ts.Diagnostics.Do_not_emit_outputs + }, + { + name: "noEmitOnError", + type: "boolean", + description: ts.Diagnostics.Do_not_emit_outputs_if_any_type_checking_errors_were_reported + }, + { + name: "noImplicitAny", + type: "boolean", + description: ts.Diagnostics.Raise_error_on_expressions_and_declarations_with_an_implied_any_type + }, + { + name: "noLib", + type: "boolean" + }, + { + name: "noLibCheck", + type: "boolean" + }, + { + name: "noResolve", + type: "boolean" + }, + { + name: "out", + type: "string", + description: ts.Diagnostics.Concatenate_and_emit_output_to_single_file, + paramType: ts.Diagnostics.FILE + }, + { + name: "outDir", + type: "string", + description: ts.Diagnostics.Redirect_output_structure_to_the_directory, + paramType: ts.Diagnostics.DIRECTORY + }, + { + name: "preserveConstEnums", + type: "boolean", + description: ts.Diagnostics.Do_not_erase_const_enum_declarations_in_generated_code + }, + { + name: "removeComments", + type: "boolean", + description: ts.Diagnostics.Do_not_emit_comments_to_output + }, + { + name: "sourceMap", + type: "boolean", + description: ts.Diagnostics.Generates_corresponding_map_file + }, + { + name: "sourceRoot", + type: "string", + description: ts.Diagnostics.Specifies_the_location_where_debugger_should_locate_TypeScript_files_instead_of_source_locations, + paramType: ts.Diagnostics.LOCATION + }, + { + name: "suppressImplicitAnyIndexErrors", + type: "boolean", + description: ts.Diagnostics.Suppress_noImplicitAny_errors_for_indexing_objects_lacking_index_signatures + }, + { + name: "target", + shortName: "t", + type: { "es3": 0 /* ES3 */, "es5": 1 /* ES5 */, "es6": 2 /* ES6 */ }, + description: ts.Diagnostics.Specify_ECMAScript_target_version_Colon_ES3_default_ES5_or_ES6_experimental, + paramType: ts.Diagnostics.VERSION, + error: ts.Diagnostics.Argument_for_target_option_must_be_es3_es5_or_es6 + }, + { + name: "version", + shortName: "v", + type: "boolean", + description: ts.Diagnostics.Print_the_compiler_s_version + }, + { + name: "watch", + shortName: "w", + type: "boolean", + description: ts.Diagnostics.Watch_input_files + } + ]; + var shortOptionNames = {}; + var optionNameMap = {}; + ts.forEach(ts.optionDeclarations, function (option) { + optionNameMap[option.name.toLowerCase()] = option; + if (option.shortName) { + shortOptionNames[option.shortName] = option.name; + } + }); + function parseCommandLine(commandLine) { + var options = { + target: 0 /* ES3 */, + module: 0 /* None */ + }; + var filenames = []; + var errors = []; + parseStrings(commandLine); + return { + options: options, + filenames: filenames, + errors: errors + }; + function parseStrings(args) { + var i = 0; + while (i < args.length) { + var s = args[i++]; + if (s.charCodeAt(0) === 64 /* at */) { + parseResponseFile(s.slice(1)); + } + else if (s.charCodeAt(0) === 45 /* minus */) { + s = s.slice(s.charCodeAt(1) === 45 /* minus */ ? 2 : 1).toLowerCase(); + if (ts.hasProperty(shortOptionNames, s)) { + s = shortOptionNames[s]; + } + if (ts.hasProperty(optionNameMap, s)) { + var opt = optionNameMap[s]; + if (!args[i] && opt.type !== "boolean") { + errors.push(ts.createCompilerDiagnostic(ts.Diagnostics.Compiler_option_0_expects_an_argument, opt.name)); + } + switch (opt.type) { + case "number": + options[opt.name] = parseInt(args[i++]); + break; + case "boolean": + options[opt.name] = true; + break; + case "string": + options[opt.name] = args[i++] || ""; + break; + default: + var map = opt.type; + var key = (args[i++] || "").toLowerCase(); + if (ts.hasProperty(map, key)) { + options[opt.name] = map[key]; + } + else { + errors.push(ts.createCompilerDiagnostic(opt.error)); + } + } + } + else { + errors.push(ts.createCompilerDiagnostic(ts.Diagnostics.Unknown_compiler_option_0, s)); + } + } + else { + filenames.push(s); + } + } + } + function parseResponseFile(filename) { + var text = ts.sys.readFile(filename); + if (!text) { + errors.push(ts.createCompilerDiagnostic(ts.Diagnostics.File_0_not_found, filename)); + return; + } + var args = []; + var pos = 0; + while (true) { + while (pos < text.length && text.charCodeAt(pos) <= 32 /* space */) + pos++; + if (pos >= text.length) + break; + var start = pos; + if (text.charCodeAt(start) === 34 /* doubleQuote */) { + pos++; + while (pos < text.length && text.charCodeAt(pos) !== 34 /* doubleQuote */) + pos++; + if (pos < text.length) { + args.push(text.substring(start + 1, pos)); + pos++; + } + else { + errors.push(ts.createCompilerDiagnostic(ts.Diagnostics.Unterminated_quoted_string_in_response_file_0, filename)); + } + } + else { + while (text.charCodeAt(pos) > 32 /* space */) + pos++; + args.push(text.substring(start, pos)); + } + } + parseStrings(args); + } + } + ts.parseCommandLine = parseCommandLine; +})(ts || (ts = {})); +var ts; (function (ts) { var OutliningElementsCollector; (function (OutliningElementsCollector) { diff --git a/bin/typescriptServices_internal.d.ts b/bin/typescriptServices_internal.d.ts index 7a19a0906a4..5731d6959de 100644 --- a/bin/typescriptServices_internal.d.ts +++ b/bin/typescriptServices_internal.d.ts @@ -48,6 +48,7 @@ declare module ts { function forEachKey(map: Map, callback: (key: string) => U): U; function lookUp(map: Map, key: string): T; function mapToArray(map: Map): T[]; + function copyMap(source: Map, target: Map): void; /** * Creates a map from the elements of an array. * @@ -142,6 +143,14 @@ declare module ts { interface StringSymbolWriter extends SymbolWriter { string(): string; } + interface EmitHost extends ScriptReferenceHost { + getSourceFiles(): SourceFile[]; + isEmitBlocked(sourceFile?: SourceFile): boolean; + getCommonSourceDirectory(): string; + getCanonicalFileName(fileName: string): string; + getNewLine(): string; + writeFile(filename: string, data: string, writeByteOrderMark: boolean, onError?: (message: string) => void): void; + } function getSingleLineStringWriter(): StringSymbolWriter; function releaseStringWriter(writer: StringSymbolWriter): void; function getFullWidth(node: Node): number; @@ -180,6 +189,7 @@ declare module ts { function getSuperContainer(node: Node): Node; function getInvokedExpression(node: CallLikeExpression): Expression; function isExpression(node: Node): boolean; + function isInstantiatedModule(node: ModuleDeclaration, preserveConstEnums: boolean): boolean; function isExternalModuleImportDeclaration(node: Node): boolean; function getExternalModuleImportDeclarationExpression(node: Node): Expression; function isInternalModuleImportDeclaration(node: Node): boolean; @@ -231,6 +241,10 @@ declare module ts { */ function collapseTextChangeRangesAcrossMultipleVersions(changes: TextChangeRange[]): TextChangeRange; } +declare module ts { + var optionDeclarations: CommandLineOption[]; + function parseCommandLine(commandLine: string[]): ParsedCommandLine; +} declare module ts { interface ListItemInfo { listItemIndex: number; diff --git a/bin/typescript_internal.d.ts b/bin/typescript_internal.d.ts index 6a40dd36d1c..e9bff0d37f9 100644 --- a/bin/typescript_internal.d.ts +++ b/bin/typescript_internal.d.ts @@ -48,6 +48,7 @@ declare module "typescript" { function forEachKey(map: Map, callback: (key: string) => U): U; function lookUp(map: Map, key: string): T; function mapToArray(map: Map): T[]; + function copyMap(source: Map, target: Map): void; /** * Creates a map from the elements of an array. * @@ -142,6 +143,14 @@ declare module "typescript" { interface StringSymbolWriter extends SymbolWriter { string(): string; } + interface EmitHost extends ScriptReferenceHost { + getSourceFiles(): SourceFile[]; + isEmitBlocked(sourceFile?: SourceFile): boolean; + getCommonSourceDirectory(): string; + getCanonicalFileName(fileName: string): string; + getNewLine(): string; + writeFile(filename: string, data: string, writeByteOrderMark: boolean, onError?: (message: string) => void): void; + } function getSingleLineStringWriter(): StringSymbolWriter; function releaseStringWriter(writer: StringSymbolWriter): void; function getFullWidth(node: Node): number; @@ -180,6 +189,7 @@ declare module "typescript" { function getSuperContainer(node: Node): Node; function getInvokedExpression(node: CallLikeExpression): Expression; function isExpression(node: Node): boolean; + function isInstantiatedModule(node: ModuleDeclaration, preserveConstEnums: boolean): boolean; function isExternalModuleImportDeclaration(node: Node): boolean; function getExternalModuleImportDeclarationExpression(node: Node): Expression; function isInternalModuleImportDeclaration(node: Node): boolean; @@ -231,6 +241,10 @@ declare module "typescript" { */ function collapseTextChangeRangesAcrossMultipleVersions(changes: TextChangeRange[]): TextChangeRange; } +declare module "typescript" { + var optionDeclarations: CommandLineOption[]; + function parseCommandLine(commandLine: string[]): ParsedCommandLine; +} declare module "typescript" { interface ListItemInfo { listItemIndex: number; diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 6327d204e4b..3ad62c1d639 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -3337,6 +3337,8 @@ module ts { case SyntaxKind.MethodDeclaration: case SyntaxKind.MethodSignature: return isContextSensitiveFunctionLikeDeclaration(node); + case SyntaxKind.ParenthesizedExpression: + return isContextSensitive((node).expression); } return false; @@ -3652,9 +3654,7 @@ module ts { var maybeCache = maybeStack[depth]; // If result is definitely true, copy assumptions to global cache, else copy to next level up var destinationCache = result === Ternary.True || depth === 0 ? relation : maybeStack[depth - 1]; - for (var p in maybeCache) { - destinationCache[p] = maybeCache[p]; - } + copyMap(/*source*/maybeCache, /*target*/destinationCache); } else { // A false result goes straight into global cache (when something is false under assumptions it @@ -4592,8 +4592,8 @@ module ts { // Get the narrowed type of a given symbol at a given location function getNarrowedTypeOfSymbol(symbol: Symbol, node: Node) { var type = getTypeOfSymbol(symbol); - // Only narrow when symbol is variable of an object, union, or type parameter type - if (node && symbol.flags & SymbolFlags.Variable && type.flags & (TypeFlags.ObjectType | TypeFlags.Union | TypeFlags.TypeParameter)) { + // Only narrow when symbol is variable of type any or an object, union, or type parameter type + if (node && symbol.flags & SymbolFlags.Variable && type.flags & (TypeFlags.Any | TypeFlags.ObjectType | TypeFlags.Union | TypeFlags.TypeParameter)) { loop: while (node.parent) { var child = node; node = node.parent; @@ -4649,21 +4649,16 @@ module ts { if (expr.left.kind !== SyntaxKind.TypeOfExpression || expr.right.kind !== SyntaxKind.StringLiteral) { return type; } - var left = expr.left; var right = expr.right; - if (left.expression.kind !== SyntaxKind.Identifier || - getResolvedSymbol(left.expression) !== symbol) { - + if (left.expression.kind !== SyntaxKind.Identifier || getResolvedSymbol(left.expression) !== symbol) { return type; } - var t = right.text; var checkType: Type = t === "string" ? stringType : t === "number" ? numberType : t === "boolean" ? booleanType : emptyObjectType; if (expr.operator === SyntaxKind.ExclamationEqualsEqualsToken) { assumeTrue = !assumeTrue; } - if (assumeTrue) { // The assumed result is true. If check was for a primitive type, that type is the narrowed type. Otherwise we can // remove the primitive types from the narrowed type. @@ -4707,8 +4702,8 @@ module ts { } function narrowTypeByInstanceof(type: Type, expr: BinaryExpression, assumeTrue: boolean): Type { - // Check that assumed result is true and we have variable symbol on the left - if (!assumeTrue || expr.left.kind !== SyntaxKind.Identifier || getResolvedSymbol(expr.left) !== symbol) { + // Check that type is not any, assumed result is true, and we have variable symbol on the left + if (type.flags & TypeFlags.Any || !assumeTrue || expr.left.kind !== SyntaxKind.Identifier || getResolvedSymbol(expr.left) !== symbol) { return type; } // Check that right operand is a function type with a prototype property @@ -4716,13 +4711,21 @@ module ts { if (!isTypeSubtypeOf(rightType, globalFunctionType)) { return type; } + // Target type is type of prototype property var prototypeProperty = getPropertyOfType(rightType, "prototype"); if (!prototypeProperty) { return type; } - var prototypeType = getTypeOfSymbol(prototypeProperty); - // Narrow to type of prototype property if it is a subtype of current type - return isTypeSubtypeOf(prototypeType, type) ? prototypeType : type; + var targetType = getTypeOfSymbol(prototypeProperty); + // Narrow to target type if it is a subtype of current type + if (isTypeSubtypeOf(targetType, type)) { + return targetType; + } + // If current type is a union type, remove all constituents that aren't subtypes of target type + if (type.flags & TypeFlags.Union) { + return getUnionType(filter((type).types, t => isTypeSubtypeOf(t, targetType))); + } + return type; } // Narrow the given type based on the given expression having the assumed boolean value @@ -5228,6 +5231,8 @@ module ts { case SyntaxKind.TemplateSpan: Debug.assert(parent.parent.kind === SyntaxKind.TemplateExpression); return getContextualTypeForSubstitutionExpression(parent.parent, node); + case SyntaxKind.ParenthesizedExpression: + return getContextualType(parent); } return undefined; } @@ -5612,8 +5617,11 @@ module ts { return unknownType; } - if (isConstEnumObjectType(objectType) && node.argumentExpression && node.argumentExpression.kind !== SyntaxKind.StringLiteral) { - error(node.argumentExpression, Diagnostics.Index_expression_arguments_in_const_enums_must_be_of_type_string); + var isConstEnum = isConstEnumObjectType(objectType); + if (isConstEnum && + (!node.argumentExpression || node.argumentExpression.kind !== SyntaxKind.StringLiteral)) { + error(node.argumentExpression, Diagnostics.A_const_enum_member_can_only_be_accessed_using_a_string_literal); + return unknownType; } // TypeScript 1.0 spec (April 2014): 4.10 Property Access @@ -5634,6 +5642,10 @@ module ts { getNodeLinks(node).resolvedSymbol = prop; return getTypeOfSymbol(prop); } + else if (isConstEnum) { + error(node.argumentExpression, Diagnostics.Property_0_does_not_exist_on_const_enum_1, name, symbolToString(objectType.symbol)); + return unknownType; + } } } @@ -6122,8 +6134,10 @@ module ts { var result = candidates; var lastParent: Node; var lastSymbol: Symbol; - var cutoffPos: number = 0; - var pos: number; + var cutoffIndex: number = 0; + var index: number; + var specializedIndex: number = -1; + var spliceIndex: number; Debug.assert(!result.length); for (var i = 0; i < signatures.length; i++) { var signature = signatures[i]; @@ -6131,25 +6145,36 @@ module ts { var parent = signature.declaration && signature.declaration.parent; if (!lastSymbol || symbol === lastSymbol) { if (lastParent && parent === lastParent) { - pos++; + index++; } else { lastParent = parent; - pos = cutoffPos; + index = cutoffIndex; } } else { // current declaration belongs to a different symbol - // set cutoffPos so re-orderings in the future won't change result set from 0 to cutoffPos - pos = cutoffPos = result.length; + // set cutoffIndex so re-orderings in the future won't change result set from 0 to cutoffIndex + index = cutoffIndex = result.length; lastParent = parent; } lastSymbol = symbol; - for (var j = result.length; j > pos; j--) { - result[j] = result[j - 1]; + // specialized signatures always need to be placed before non-specialized signatures regardless + // of the cutoff position; see GH#1133 + if (signature.hasStringLiterals) { + specializedIndex++; + spliceIndex = specializedIndex; + // The cutoff index always needs to be greater than or equal to the specialized signature index + // in order to prevent non-specialized signatures from being added before a specialized + // signature. + cutoffIndex++; } - result[pos] = signature; + else { + spliceIndex = index; + } + + result.splice(spliceIndex, 0, signature); } } } @@ -7181,12 +7206,15 @@ module ts { checkVariableLikeDeclaration(node); var func = getContainingFunction(node); - if (node.flags & (NodeFlags.Public | NodeFlags.Private | NodeFlags.Protected)) { + if (node.flags & NodeFlags.AccessibilityModifier) { func = getContainingFunction(node); if (!(func.kind === SyntaxKind.Constructor && nodeIsPresent(func.body))) { error(node, Diagnostics.A_parameter_property_is_only_allowed_in_a_constructor_implementation); } } + if (node.questionToken && isBindingPattern(node.name) && func.body) { + error(node, Diagnostics.A_binding_pattern_parameter_cannot_be_optional_in_an_implementation_signature); + } if (node.dotDotDotToken) { if (!isArrayType(getTypeOfSymbol(node.symbol))) { error(node, Diagnostics.A_rest_parameter_must_be_of_an_array_type); @@ -7200,17 +7228,20 @@ module ts { checkGrammarIndexSignature(node); } // TODO (yuisu): Remove this check in else-if when SyntaxKind.Construct is moved and ambient context is handled - else if (node.kind === SyntaxKind.FunctionType || node.kind === SyntaxKind.FunctionDeclaration || node.kind === SyntaxKind.ConstructorType || + else if (node.kind === SyntaxKind.FunctionType || node.kind === SyntaxKind.FunctionDeclaration || node.kind === SyntaxKind.ConstructorType || node.kind === SyntaxKind.CallSignature || node.kind === SyntaxKind.Constructor || node.kind === SyntaxKind.ConstructSignature){ checkGrammarFunctionLikeDeclaration(node); } checkTypeParameters(node.typeParameters); + forEach(node.parameters, checkParameter); + if (node.type) { checkSourceElement(node.type); } + if (produceDiagnostics) { checkCollisionWithArgumentsInGeneratedCode(node); if (compilerOptions.noImplicitAny && !node.type) { @@ -10161,6 +10192,9 @@ module ts { else if (node.kind === SyntaxKind.InterfaceDeclaration && flags & NodeFlags.Ambient) { return grammarErrorOnNode(lastDeclare, Diagnostics.A_declare_modifier_cannot_be_used_with_an_interface_declaration, "declare"); } + else if (node.kind === SyntaxKind.Parameter && (flags & NodeFlags.AccessibilityModifier) && isBindingPattern((node).name)) { + return grammarErrorOnNode(node, Diagnostics.A_parameter_property_may_not_be_a_binding_pattern); + } } function checkGrammarForDisallowedTrailingComma(list: NodeArray): boolean { diff --git a/src/compiler/commandLineParser.ts b/src/compiler/commandLineParser.ts index 9fe59b1ba27..fa31f25f7c3 100644 --- a/src/compiler/commandLineParser.ts +++ b/src/compiler/commandLineParser.ts @@ -67,7 +67,7 @@ module ts { { name: "noImplicitAny", type: "boolean", - description: Diagnostics.Warn_on_expressions_and_declarations_with_an_implied_any_type, + description: Diagnostics.Raise_error_on_expressions_and_declarations_with_an_implied_any_type, }, { name: "noLib", diff --git a/src/compiler/core.ts b/src/compiler/core.ts index 4ba93729c36..2e5a471bb27 100644 --- a/src/compiler/core.ts +++ b/src/compiler/core.ts @@ -208,6 +208,12 @@ module ts { return result; } + export function copyMap(source: Map, target: Map): void { + for (var p in source) { + target[p] = source[p]; + } + } + /** * Creates a map from the elements of an array. * diff --git a/src/compiler/diagnosticInformationMap.generated.ts b/src/compiler/diagnosticInformationMap.generated.ts index 99d8d0b72fb..9d62ee0e030 100644 --- a/src/compiler/diagnosticInformationMap.generated.ts +++ b/src/compiler/diagnosticInformationMap.generated.ts @@ -146,6 +146,7 @@ module ts { Modifiers_cannot_appear_here: { code: 1184, category: DiagnosticCategory.Error, key: "Modifiers cannot appear here." }, Merge_conflict_marker_encountered: { code: 1185, category: DiagnosticCategory.Error, key: "Merge conflict marker encountered." }, A_rest_element_cannot_have_an_initializer: { code: 1186, category: DiagnosticCategory.Error, key: "A rest element cannot have an initializer." }, + A_parameter_property_may_not_be_a_binding_pattern: { code: 1187, category: DiagnosticCategory.Error, key: "A parameter property may not be a binding pattern." }, Duplicate_identifier_0: { code: 2300, category: DiagnosticCategory.Error, key: "Duplicate identifier '{0}'." }, Initializer_of_instance_member_variable_0_cannot_reference_identifier_1_declared_in_the_constructor: { code: 2301, category: DiagnosticCategory.Error, key: "Initializer of instance member variable '{0}' cannot reference identifier '{1}' declared in the constructor." }, Static_members_cannot_reference_class_type_parameters: { code: 2302, category: DiagnosticCategory.Error, key: "Static members cannot reference class type parameters." }, @@ -297,6 +298,7 @@ module ts { Type_0_has_no_property_1: { code: 2460, category: DiagnosticCategory.Error, key: "Type '{0}' has no property '{1}'." }, Type_0_is_not_an_array_type: { code: 2461, category: DiagnosticCategory.Error, key: "Type '{0}' is not an array type." }, A_rest_element_must_be_last_in_an_array_destructuring_pattern: { code: 2462, category: DiagnosticCategory.Error, key: "A rest element must be last in an array destructuring pattern" }, + A_binding_pattern_parameter_cannot_be_optional_in_an_implementation_signature: { code: 2463, category: DiagnosticCategory.Error, key: "A binding pattern parameter cannot be optional in an implementation signature." }, Import_declaration_0_is_using_private_name_1: { code: 4000, category: DiagnosticCategory.Error, key: "Import declaration '{0}' is using private name '{1}'." }, Type_parameter_0_of_exported_class_has_or_is_using_private_name_1: { code: 4002, category: DiagnosticCategory.Error, key: "Type parameter '{0}' of exported class has or is using private name '{1}'." }, Type_parameter_0_of_exported_interface_has_or_is_using_private_name_1: { code: 4004, category: DiagnosticCategory.Error, key: "Type parameter '{0}' of exported interface has or is using private name '{1}'." }, @@ -369,9 +371,10 @@ module ts { Enum_declarations_must_all_be_const_or_non_const: { code: 4082, category: DiagnosticCategory.Error, key: "Enum declarations must all be const or non-const." }, In_const_enum_declarations_member_initializer_must_be_constant_expression: { code: 4083, category: DiagnosticCategory.Error, key: "In 'const' enum declarations member initializer must be constant expression.", isEarly: true }, const_enums_can_only_be_used_in_property_or_index_access_expressions_or_the_right_hand_side_of_an_import_declaration_or_export_assignment: { code: 4084, category: DiagnosticCategory.Error, key: "'const' enums can only be used in property or index access expressions or the right hand side of an import declaration or export assignment." }, - Index_expression_arguments_in_const_enums_must_be_of_type_string: { code: 4085, category: DiagnosticCategory.Error, key: "Index expression arguments in 'const' enums must be of type 'string'." }, + A_const_enum_member_can_only_be_accessed_using_a_string_literal: { code: 4085, category: DiagnosticCategory.Error, key: "A const enum member can only be accessed using a string literal.", isEarly: true }, const_enum_member_initializer_was_evaluated_to_a_non_finite_value: { code: 4086, category: DiagnosticCategory.Error, key: "'const' enum member initializer was evaluated to a non-finite value." }, const_enum_member_initializer_was_evaluated_to_disallowed_value_NaN: { code: 4087, category: DiagnosticCategory.Error, key: "'const' enum member initializer was evaluated to disallowed value 'NaN'." }, + Property_0_does_not_exist_on_const_enum_1: { code: 4088, category: DiagnosticCategory.Error, key: "Property '{0}' does not exist on 'const' enum '{1}'.", isEarly: true }, The_current_host_does_not_support_the_0_option: { code: 5001, category: DiagnosticCategory.Error, key: "The current host does not support the '{0}' option." }, Cannot_find_the_common_subdirectory_path_for_the_input_files: { code: 5009, category: DiagnosticCategory.Error, key: "Cannot find the common subdirectory path for the input files." }, Cannot_read_file_0_Colon_1: { code: 5012, category: DiagnosticCategory.Error, key: "Cannot read file '{0}': {1}" }, @@ -419,7 +422,7 @@ module ts { Unsupported_locale_0: { code: 6049, category: DiagnosticCategory.Error, key: "Unsupported locale '{0}'." }, Unable_to_open_file_0: { code: 6050, category: DiagnosticCategory.Error, key: "Unable to open file '{0}'." }, Corrupted_locale_file_0: { code: 6051, category: DiagnosticCategory.Error, key: "Corrupted locale file {0}." }, - Warn_on_expressions_and_declarations_with_an_implied_any_type: { code: 6052, category: DiagnosticCategory.Message, key: "Warn on expressions and declarations with an implied 'any' type." }, + Raise_error_on_expressions_and_declarations_with_an_implied_any_type: { code: 6052, category: DiagnosticCategory.Message, key: "Raise error on expressions and declarations with an implied 'any' type." }, File_0_not_found: { code: 6053, category: DiagnosticCategory.Error, key: "File '{0}' not found." }, File_0_must_have_extension_ts_or_d_ts: { code: 6054, category: DiagnosticCategory.Error, key: "File '{0}' must have extension '.ts' or '.d.ts'." }, Suppress_noImplicitAny_errors_for_indexing_objects_lacking_index_signatures: { code: 6055, category: DiagnosticCategory.Message, key: "Suppress noImplicitAny errors for indexing objects lacking index signatures." }, diff --git a/src/compiler/diagnosticMessages.json b/src/compiler/diagnosticMessages.json index 5bec5301721..ee962edc3a0 100644 --- a/src/compiler/diagnosticMessages.json +++ b/src/compiler/diagnosticMessages.json @@ -224,7 +224,7 @@ "A 'declare' modifier cannot be used with an import declaration.": { "category": "Error", "code": 1079, - "isEarly": true + "isEarly": true }, "Invalid 'reference' directive syntax.": { "category": "Error", @@ -659,7 +659,7 @@ "An implementation cannot be declared in ambient contexts.": { "category": "Error", "code": 1184, - "isEarly": true + "isEarly": true }, "Modifiers cannot appear here.": { "category": "Error", @@ -673,6 +673,10 @@ "category": "Error", "code": 1186 }, + "A parameter property may not be a binding pattern.": { + "category": "Error", + "code": 1187 + }, "Duplicate identifier '{0}'.": { "category": "Error", @@ -1282,6 +1286,10 @@ "category": "Error", "code": 2462 }, + "A binding pattern parameter cannot be optional in an implementation signature.": { + "category": "Error", + "code": 2463 + }, "Import declaration '{0}' is using private name '{1}'.": { "category": "Error", @@ -1572,9 +1580,10 @@ "category": "Error", "code": 4084 }, - "Index expression arguments in 'const' enums must be of type 'string'.": { + "A const enum member can only be accessed using a string literal.": { "category": "Error", - "code": 4085 + "code": 4085, + "isEarly": true }, "'const' enum member initializer was evaluated to a non-finite value.": { "category": "Error", @@ -1584,6 +1593,11 @@ "category": "Error", "code": 4087 }, + "Property '{0}' does not exist on 'const' enum '{1}'.": { + "category": "Error", + "code": 4088, + "isEarly": true + }, "The current host does not support the '{0}' option.": { "category": "Error", "code": 5001 @@ -1772,7 +1786,7 @@ "category": "Error", "code": 6051 }, - "Warn on expressions and declarations with an implied 'any' type.": { + "Raise error on expressions and declarations with an implied 'any' type.": { "category": "Message", "code": 6052 }, diff --git a/src/compiler/emitter.ts b/src/compiler/emitter.ts index 186dd7b0758..d82e577971d 100644 --- a/src/compiler/emitter.ts +++ b/src/compiler/emitter.ts @@ -2057,9 +2057,15 @@ module ts { write("("); } - emitLiteral(node.head); + var headEmitted = false; + if (shouldEmitTemplateHead()) { + emitLiteral(node.head); + headEmitted = true; + } + + for (var i = 0; i < node.templateSpans.length; i++) { + var templateSpan = node.templateSpans[i]; - forEach(node.templateSpans, templateSpan => { // Check if the expression has operands and binds its operands less closely than binary '+'. // If it does, we need to wrap the expression in parentheses. Otherwise, something like // `abc${ 1 << 2 }` @@ -2071,7 +2077,14 @@ module ts { // "abc" + (1 << 2) + "" var needsParens = templateSpan.expression.kind !== SyntaxKind.ParenthesizedExpression && comparePrecedenceToBinaryPlus(templateSpan.expression) !== Comparison.GreaterThan; - write(" + "); + + if (i > 0 || headEmitted) { + // If this is the first span and the head was not emitted, then this templateSpan's + // expression will be the first to be emitted. Don't emit the preceding ' + ' in that + // case. + write(" + "); + } + emitParenthesized(templateSpan.expression, needsParens); // Only emit if the literal is non-empty. // The binary '+' operator is left-associative, so the first string concatenation @@ -2081,12 +2094,34 @@ module ts { write(" + ") emitLiteral(templateSpan.literal); } - }); + } if (emitOuterParens) { write(")"); } + function shouldEmitTemplateHead() { + // If this expression has an empty head literal and the first template span has a non-empty + // literal, then emitting the empty head literal is not necessary. + // `${ foo } and ${ bar }` + // can be emitted as + // foo + " and " + bar + // This is because it is only required that one of the first two operands in the emit + // output must be a string literal, so that the other operand and all following operands + // are forced into strings. + // + // If the first template span has an empty literal, then the head must still be emitted. + // `${ foo }${ bar }` + // must still be emitted as + // "" + foo + bar + + // There is always atleast one templateSpan in this code path, since + // NoSubstitutionTemplateLiterals are directly emitted via emitLiteral() + Debug.assert(node.templateSpans.length !== 0); + + return node.head.text.length !== 0 || node.templateSpans[0].literal.text.length === 0; + } + function templateNeedsParens(template: TemplateExpression, parent: Expression) { switch (parent.kind) { case SyntaxKind.CallExpression: diff --git a/src/compiler/parser.ts b/src/compiler/parser.ts index 00cd54b94eb..5ae44e5ff39 100644 --- a/src/compiler/parser.ts +++ b/src/compiler/parser.ts @@ -12,43 +12,50 @@ module ts { return new (getNodeConstructor(kind))(); } + function visitNode(cbNode: (node: Node) => T, node: Node): T { + if (node) { + return cbNode(node); + } + } + + function visitNodeArray(cbNodes: (nodes: Node[]) => T, nodes: Node[]) { + if (nodes) { + return cbNodes(nodes); + } + } + + function visitEachNode(cbNode: (node: Node) => T, nodes: Node[]) { + if (nodes) { + for (var i = 0, len = nodes.length; i < len; i++) { + var result = cbNode(nodes[i]); + if (result) { + return result; + } + } + } + } + // Invokes a callback for each child of the given node. The 'cbNode' callback is invoked for all child nodes // stored in properties. If a 'cbNodes' callback is specified, it is invoked for embedded arrays; otherwise, // embedded arrays are flattened and the 'cbNode' callback is invoked for each element. If a callback returns // a truthy value, iteration stops and that value is returned. Otherwise, undefined is returned. - export function forEachChild(node: Node, cbNode: (node: Node) => T, cbNodes?: (nodes: Node[]) => T): T { - function child(node: Node): T { - if (node) { - return cbNode(node); - } - } - function children(nodes: Node[]) { - if (nodes) { - if (cbNodes) { - return cbNodes(nodes); - } - - for (var i = 0, len = nodes.length; i < len; i++) { - var result = cbNode(nodes[i]) - if (result) { - return result; - } - } - - return undefined; - } - } + export function forEachChild(node: Node, cbNode: (node: Node) => T, cbNodeArray?: (nodes: Node[]) => T): T { if (!node) { return; } + // The visitXXX functions could be written as local functions that close over the cbNode and cbNodeArray + // callback parameters, but that causes a closure allocation for each invocation with noticeable effects + // on performance. + var visitNodes: (cb: (node: Node | Node[]) => T, nodes: Node[]) => T = cbNodeArray ? visitNodeArray : visitEachNode; + var cbNodes = cbNodeArray || cbNode; switch (node.kind) { case SyntaxKind.QualifiedName: - return child((node).left) || - child((node).right); + return visitNode(cbNode, (node).left) || + visitNode(cbNode, (node).right); case SyntaxKind.TypeParameter: - return child((node).name) || - child((node).constraint) || - child((node).expression); + return visitNode(cbNode, (node).name) || + visitNode(cbNode, (node).constraint) || + visitNode(cbNode, (node).expression); case SyntaxKind.Parameter: case SyntaxKind.PropertyDeclaration: case SyntaxKind.PropertySignature: @@ -56,22 +63,22 @@ module ts { case SyntaxKind.ShorthandPropertyAssignment: case SyntaxKind.VariableDeclaration: case SyntaxKind.BindingElement: - return children(node.modifiers) || - child((node).propertyName) || - child((node).dotDotDotToken) || - child((node).name) || - child((node).questionToken) || - child((node).type) || - child((node).initializer); + return visitNodes(cbNodes, node.modifiers) || + visitNode(cbNode, (node).propertyName) || + visitNode(cbNode, (node).dotDotDotToken) || + visitNode(cbNode, (node).name) || + visitNode(cbNode, (node).questionToken) || + visitNode(cbNode, (node).type) || + visitNode(cbNode, (node).initializer); case SyntaxKind.FunctionType: case SyntaxKind.ConstructorType: case SyntaxKind.CallSignature: case SyntaxKind.ConstructSignature: case SyntaxKind.IndexSignature: - return children(node.modifiers) || - children((node).typeParameters) || - children((node).parameters) || - child((node).type); + return visitNodes(cbNodes, node.modifiers) || + visitNodes(cbNodes, (node).typeParameters) || + visitNodes(cbNodes, (node).parameters) || + visitNode(cbNode, (node).type); case SyntaxKind.MethodDeclaration: case SyntaxKind.MethodSignature: case SyntaxKind.Constructor: @@ -80,182 +87,182 @@ module ts { case SyntaxKind.FunctionExpression: case SyntaxKind.FunctionDeclaration: case SyntaxKind.ArrowFunction: - return children(node.modifiers) || - child((node).asteriskToken) || - child((node).name) || - child((node).questionToken) || - children((node).typeParameters) || - children((node).parameters) || - child((node).type) || - child((node).body); + return visitNodes(cbNodes, node.modifiers) || + visitNode(cbNode, (node).asteriskToken) || + visitNode(cbNode, (node).name) || + visitNode(cbNode, (node).questionToken) || + visitNodes(cbNodes, (node).typeParameters) || + visitNodes(cbNodes, (node).parameters) || + visitNode(cbNode, (node).type) || + visitNode(cbNode, (node).body); case SyntaxKind.TypeReference: - return child((node).typeName) || - children((node).typeArguments); + return visitNode(cbNode, (node).typeName) || + visitNodes(cbNodes, (node).typeArguments); case SyntaxKind.TypeQuery: - return child((node).exprName); + return visitNode(cbNode, (node).exprName); case SyntaxKind.TypeLiteral: - return children((node).members); + return visitNodes(cbNodes, (node).members); case SyntaxKind.ArrayType: - return child((node).elementType); + return visitNode(cbNode, (node).elementType); case SyntaxKind.TupleType: - return children((node).elementTypes); + return visitNodes(cbNodes, (node).elementTypes); case SyntaxKind.UnionType: - return children((node).types); + return visitNodes(cbNodes, (node).types); case SyntaxKind.ParenthesizedType: - return child((node).type); + return visitNode(cbNode, (node).type); case SyntaxKind.ObjectBindingPattern: case SyntaxKind.ArrayBindingPattern: - return children((node).elements); + return visitNodes(cbNodes, (node).elements); case SyntaxKind.ArrayLiteralExpression: - return children((node).elements); + return visitNodes(cbNodes, (node).elements); case SyntaxKind.ObjectLiteralExpression: - return children((node).properties); + return visitNodes(cbNodes, (node).properties); case SyntaxKind.PropertyAccessExpression: - return child((node).expression) || - child((node).name); + return visitNode(cbNode, (node).expression) || + visitNode(cbNode, (node).name); case SyntaxKind.ElementAccessExpression: - return child((node).expression) || - child((node).argumentExpression); + return visitNode(cbNode, (node).expression) || + visitNode(cbNode, (node).argumentExpression); case SyntaxKind.CallExpression: case SyntaxKind.NewExpression: - return child((node).expression) || - children((node).typeArguments) || - children((node).arguments); + return visitNode(cbNode, (node).expression) || + visitNodes(cbNodes, (node).typeArguments) || + visitNodes(cbNodes, (node).arguments); case SyntaxKind.TaggedTemplateExpression: - return child((node).tag) || - child((node).template); + return visitNode(cbNode, (node).tag) || + visitNode(cbNode, (node).template); case SyntaxKind.TypeAssertionExpression: - return child((node).type) || - child((node).expression); + return visitNode(cbNode, (node).type) || + visitNode(cbNode, (node).expression); case SyntaxKind.ParenthesizedExpression: - return child((node).expression); + return visitNode(cbNode, (node).expression); case SyntaxKind.DeleteExpression: - return child((node).expression); + return visitNode(cbNode, (node).expression); case SyntaxKind.TypeOfExpression: - return child((node).expression); + return visitNode(cbNode, (node).expression); case SyntaxKind.VoidExpression: - return child((node).expression); + return visitNode(cbNode, (node).expression); case SyntaxKind.PrefixUnaryExpression: - return child((node).operand); + return visitNode(cbNode, (node).operand); case SyntaxKind.YieldExpression: - return child((node).asteriskToken) || - child((node).expression); + return visitNode(cbNode, (node).asteriskToken) || + visitNode(cbNode, (node).expression); case SyntaxKind.PostfixUnaryExpression: - return child((node).operand); + return visitNode(cbNode, (node).operand); case SyntaxKind.BinaryExpression: - return child((node).left) || - child((node).right); + return visitNode(cbNode, (node).left) || + visitNode(cbNode, (node).right); case SyntaxKind.ConditionalExpression: - return child((node).condition) || - child((node).whenTrue) || - child((node).whenFalse); + return visitNode(cbNode, (node).condition) || + visitNode(cbNode, (node).whenTrue) || + visitNode(cbNode, (node).whenFalse); case SyntaxKind.SpreadElementExpression: - return child((node).expression); + return visitNode(cbNode, (node).expression); case SyntaxKind.Block: case SyntaxKind.ModuleBlock: - return children((node).statements); + return visitNodes(cbNodes, (node).statements); case SyntaxKind.SourceFile: - return children((node).statements) || - child((node).endOfFileToken); + return visitNodes(cbNodes, (node).statements) || + visitNode(cbNode, (node).endOfFileToken); case SyntaxKind.VariableStatement: - return children(node.modifiers) || - child((node).declarationList); + return visitNodes(cbNodes, node.modifiers) || + visitNode(cbNode, (node).declarationList); case SyntaxKind.VariableDeclarationList: - return children((node).declarations); + return visitNodes(cbNodes, (node).declarations); case SyntaxKind.ExpressionStatement: - return child((node).expression); + return visitNode(cbNode, (node).expression); case SyntaxKind.IfStatement: - return child((node).expression) || - child((node).thenStatement) || - child((node).elseStatement); + return visitNode(cbNode, (node).expression) || + visitNode(cbNode, (node).thenStatement) || + visitNode(cbNode, (node).elseStatement); case SyntaxKind.DoStatement: - return child((node).statement) || - child((node).expression); + return visitNode(cbNode, (node).statement) || + visitNode(cbNode, (node).expression); case SyntaxKind.WhileStatement: - return child((node).expression) || - child((node).statement); + return visitNode(cbNode, (node).expression) || + visitNode(cbNode, (node).statement); case SyntaxKind.ForStatement: - return child((node).initializer) || - child((node).condition) || - child((node).iterator) || - child((node).statement); + return visitNode(cbNode, (node).initializer) || + visitNode(cbNode, (node).condition) || + visitNode(cbNode, (node).iterator) || + visitNode(cbNode, (node).statement); case SyntaxKind.ForInStatement: - return child((node).initializer) || - child((node).expression) || - child((node).statement); + return visitNode(cbNode, (node).initializer) || + visitNode(cbNode, (node).expression) || + visitNode(cbNode, (node).statement); case SyntaxKind.ContinueStatement: case SyntaxKind.BreakStatement: - return child((node).label); + return visitNode(cbNode, (node).label); case SyntaxKind.ReturnStatement: - return child((node).expression); + return visitNode(cbNode, (node).expression); case SyntaxKind.WithStatement: - return child((node).expression) || - child((node).statement); + return visitNode(cbNode, (node).expression) || + visitNode(cbNode, (node).statement); case SyntaxKind.SwitchStatement: - return child((node).expression) || - children((node).clauses); + return visitNode(cbNode, (node).expression) || + visitNodes(cbNodes, (node).clauses); case SyntaxKind.CaseClause: - return child((node).expression) || - children((node).statements); + return visitNode(cbNode, (node).expression) || + visitNodes(cbNodes, (node).statements); case SyntaxKind.DefaultClause: - return children((node).statements); + return visitNodes(cbNodes, (node).statements); case SyntaxKind.LabeledStatement: - return child((node).label) || - child((node).statement); + return visitNode(cbNode, (node).label) || + visitNode(cbNode, (node).statement); case SyntaxKind.ThrowStatement: - return child((node).expression); + return visitNode(cbNode, (node).expression); case SyntaxKind.TryStatement: - return child((node).tryBlock) || - child((node).catchClause) || - child((node).finallyBlock); + return visitNode(cbNode, (node).tryBlock) || + visitNode(cbNode, (node).catchClause) || + visitNode(cbNode, (node).finallyBlock); case SyntaxKind.CatchClause: - return child((node).name) || - child((node).type) || - child((node).block); + return visitNode(cbNode, (node).name) || + visitNode(cbNode, (node).type) || + visitNode(cbNode, (node).block); case SyntaxKind.ClassDeclaration: - return children(node.modifiers) || - child((node).name) || - children((node).typeParameters) || - children((node).heritageClauses) || - children((node).members); + return visitNodes(cbNodes, node.modifiers) || + visitNode(cbNode, (node).name) || + visitNodes(cbNodes, (node).typeParameters) || + visitNodes(cbNodes, (node).heritageClauses) || + visitNodes(cbNodes, (node).members); case SyntaxKind.InterfaceDeclaration: - return children(node.modifiers) || - child((node).name) || - children((node).typeParameters) || - children((node).heritageClauses) || - children((node).members); + return visitNodes(cbNodes, node.modifiers) || + visitNode(cbNode, (node).name) || + visitNodes(cbNodes, (node).typeParameters) || + visitNodes(cbNodes, (node).heritageClauses) || + visitNodes(cbNodes, (node).members); case SyntaxKind.TypeAliasDeclaration: - return children(node.modifiers) || - child((node).name) || - child((node).type); + return visitNodes(cbNodes, node.modifiers) || + visitNode(cbNode, (node).name) || + visitNode(cbNode, (node).type); case SyntaxKind.EnumDeclaration: - return children(node.modifiers) || - child((node).name) || - children((node).members); + return visitNodes(cbNodes, node.modifiers) || + visitNode(cbNode, (node).name) || + visitNodes(cbNodes, (node).members); case SyntaxKind.EnumMember: - return child((node).name) || - child((node).initializer); + return visitNode(cbNode, (node).name) || + visitNode(cbNode, (node).initializer); case SyntaxKind.ModuleDeclaration: - return children(node.modifiers) || - child((node).name) || - child((node).body); + return visitNodes(cbNodes, node.modifiers) || + visitNode(cbNode, (node).name) || + visitNode(cbNode, (node).body); case SyntaxKind.ImportDeclaration: - return children(node.modifiers) || - child((node).name) || - child((node).moduleReference); + return visitNodes(cbNodes, node.modifiers) || + visitNode(cbNode, (node).name) || + visitNode(cbNode, (node).moduleReference); case SyntaxKind.ExportAssignment: - return children(node.modifiers) || - child((node).exportName); + return visitNodes(cbNodes, node.modifiers) || + visitNode(cbNode, (node).exportName); case SyntaxKind.TemplateExpression: - return child((node).head) || children((node).templateSpans); + return visitNode(cbNode, (node).head) || visitNodes(cbNodes, (node).templateSpans); case SyntaxKind.TemplateSpan: - return child((node).expression) || child((node).literal); + return visitNode(cbNode, (node).expression) || visitNode(cbNode, (node).literal); case SyntaxKind.ComputedPropertyName: - return child((node).expression); + return visitNode(cbNode, (node).expression); case SyntaxKind.HeritageClause: - return children((node).types); + return visitNodes(cbNodes, (node).types); case SyntaxKind.ExternalModuleReference: - return child((node).expression); + return visitNode(cbNode, (node).expression); } } @@ -1388,7 +1395,10 @@ module ts { } function canFollowModifier(): boolean { - return token === SyntaxKind.OpenBracketToken || token === SyntaxKind.AsteriskToken || isLiteralPropertyName(); + return token === SyntaxKind.OpenBracketToken + || token === SyntaxKind.OpenBraceToken + || token === SyntaxKind.AsteriskToken + || isLiteralPropertyName(); } // True if positioned at the start of a list element diff --git a/src/compiler/program.ts b/src/compiler/program.ts index b506a86786b..fc3cc0682d1 100644 --- a/src/compiler/program.ts +++ b/src/compiler/program.ts @@ -185,7 +185,10 @@ module ts { } } else { - if (!(findSourceFile(filename + ".ts", isDefaultLib, refFile, refPos, refEnd) || findSourceFile(filename + ".d.ts", isDefaultLib, refFile, refPos, refEnd))) { + if (options.allowNonTsExtensions && !findSourceFile(filename, isDefaultLib, refFile, refPos, refEnd)) { + diagnostic = Diagnostics.File_0_not_found; + } + else if (!findSourceFile(filename + ".ts", isDefaultLib, refFile, refPos, refEnd) && !findSourceFile(filename + ".d.ts", isDefaultLib, refFile, refPos, refEnd)) { diagnostic = Diagnostics.File_0_not_found; filename += ".ts"; } diff --git a/src/compiler/scanner.ts b/src/compiler/scanner.ts index 427bc0012d6..2a0363f7f78 100644 --- a/src/compiler/scanner.ts +++ b/src/compiler/scanner.ts @@ -1039,7 +1039,7 @@ module ts { value = 0; } tokenValue = "" + value; - return SyntaxKind.NumericLiteral; + return token = SyntaxKind.NumericLiteral; } else if (pos + 2 < len && (text.charCodeAt(pos + 1) === CharacterCodes.O || text.charCodeAt(pos + 1) === CharacterCodes.o)) { pos += 2; @@ -1049,7 +1049,7 @@ module ts { value = 0; } tokenValue = "" + value; - return SyntaxKind.NumericLiteral; + return token = SyntaxKind.NumericLiteral; } // Try to parse as an octal if (pos + 1 < len && isOctalDigit(text.charCodeAt(pos + 1))) { diff --git a/src/compiler/types.ts b/src/compiler/types.ts index 60ed8352b9a..9ebab8dc220 100644 --- a/src/compiler/types.ts +++ b/src/compiler/types.ts @@ -1331,8 +1331,6 @@ module ts { // Generic class and interface types export interface GenericType extends InterfaceType, TypeReference { instantiations: Map; // Generic instantiation cache - openReferenceTargets: GenericType[]; // Open type reference targets - openReferenceChecks: Map; // Open type reference check cache } export interface TupleType extends ObjectType { diff --git a/src/harness/harness.ts b/src/harness/harness.ts index ba84a3c9ffd..ecae4ee47a4 100644 --- a/src/harness/harness.ts +++ b/src/harness/harness.ts @@ -810,7 +810,9 @@ module Harness { export function createCompilerHost(inputFiles: { unitName: string; content: string; }[], writeFile: (fn: string, contents: string, writeByteOrderMark: boolean) => void, scriptTarget: ts.ScriptTarget, - useCaseSensitiveFileNames: boolean): ts.CompilerHost { + useCaseSensitiveFileNames: boolean, + // the currentDirectory is needed for rwcRunner to passed in specified current directory to compiler host + currentDirectory?: string): ts.CompilerHost { // Local get canonical file name function, that depends on passed in parameter for useCaseSensitiveFileNames function getCanonicalFileName(fileName: string): string { @@ -818,6 +820,8 @@ module Harness { } var filemap: { [filename: string]: ts.SourceFile; } = {}; + var getCurrentDirectory = currentDirectory === undefined ? ts.sys.getCurrentDirectory : () => currentDirectory; + // Register input files function register(file: { unitName: string; content: string; }) { if (file.content !== undefined) { @@ -828,11 +832,15 @@ module Harness { inputFiles.forEach(register); return { - getCurrentDirectory: ts.sys.getCurrentDirectory, + getCurrentDirectory, getSourceFile: (fn, languageVersion) => { if (Object.prototype.hasOwnProperty.call(filemap, getCanonicalFileName(fn))) { return filemap[getCanonicalFileName(fn)]; } + else if (currentDirectory) { + var canonicalAbsolutePath = getCanonicalFileName(ts.getNormalizedAbsolutePath(fn, currentDirectory)); + return Object.prototype.hasOwnProperty.call(filemap, getCanonicalFileName(canonicalAbsolutePath)) ? filemap[canonicalAbsolutePath] : undefined; + } else if (fn === fourslashFilename) { var tsFn = 'tests/cases/fourslash/' + fourslashFilename; fourslashSourceFile = fourslashSourceFile || ts.createSourceFile(tsFn, Harness.IO.readFile(tsFn), scriptTarget); @@ -909,7 +917,9 @@ module Harness { otherFiles: { unitName: string; content: string }[], onComplete: (result: CompilerResult, program: ts.Program) => void, settingsCallback?: (settings: ts.CompilerOptions) => void, - options?: ts.CompilerOptions) { + options?: ts.CompilerOptions, + // Current directory is needed for rwcRunner to be able to use currentDirectory defined in json file + currentDirectory?: string) { options = options || { noResolve: false }; options.target = options.target || ts.ScriptTarget.ES3; @@ -1063,8 +1073,7 @@ module Harness { var programFiles = inputFiles.map(file => file.unitName); var program = ts.createProgram(programFiles, options, createCompilerHost(inputFiles.concat(otherFiles), (fn, contents, writeByteOrderMark) => fileOutputs.push({ fileName: fn, code: contents, writeByteOrderMark: writeByteOrderMark }), - options.target, - useCaseSensitiveFileNames)); + options.target, useCaseSensitiveFileNames, currentDirectory)); var checker = program.getTypeChecker(/*produceDiagnostics*/ true); @@ -1095,7 +1104,9 @@ module Harness { otherFiles: { unitName: string; content: string; }[], result: CompilerResult, settingsCallback?: (settings: ts.CompilerOptions) => void, - options?: ts.CompilerOptions) { + options?: ts.CompilerOptions, + // Current directory is needed for rwcRunner to be able to use currentDirectory defined in json file + currentDirectory?: string) { if (options.declaration && result.errors.length === 0 && result.declFilesCode.length !== result.files.length) { throw new Error('There were no errors and declFiles generated did not match number of js files generated'); } @@ -1108,9 +1119,8 @@ module Harness { ts.forEach(inputFiles, file => addDtsFile(file, declInputFiles)); ts.forEach(otherFiles, file => addDtsFile(file, declOtherFiles)); - this.compileFiles(declInputFiles, declOtherFiles, function (compileResult) { - declResult = compileResult; - }, settingsCallback, options); + this.compileFiles(declInputFiles, declOtherFiles, function (compileResult) { declResult = compileResult; }, + settingsCallback, options, currentDirectory); return { declInputFiles, declOtherFiles, declResult }; } diff --git a/src/harness/instrumenter.ts b/src/harness/instrumenter.ts index 61f6a8f2ec3..1c9b9af78d2 100644 --- a/src/harness/instrumenter.ts +++ b/src/harness/instrumenter.ts @@ -3,11 +3,11 @@ var fs: any = require('fs'); var path: any = require('path'); function instrumentForRecording(fn: string, tscPath: string) { - instrument(tscPath, 'sys = Playback.wrapSystem(sys); sys.startRecord("' + fn + '");', 'sys.endRecord();'); + instrument(tscPath, 'ts.sys = Playback.wrapSystem(ts.sys); ts.sys.startRecord("' + fn + '");', 'ts.sys.endRecord();'); } function instrumentForReplay(logFilename: string, tscPath: string) { - instrument(tscPath, 'sys = Playback.wrapSystem(sys); sys.startReplay("' + logFilename + '");'); + instrument(tscPath, 'ts.sys = Playback.wrapSystem(ts.sys); ts.sys.startReplay("' + logFilename + '");'); } function instrument(tscPath: string, prepareCode: string, cleanupCode: string = '') { @@ -27,8 +27,12 @@ function instrument(tscPath: string, prepareCode: string, cleanupCode: string = fs.readFile(path.resolve(path.dirname(tscPath) + '/loggedIO.js'), 'utf-8', (err: any, loggerContent: string) => { if (err) throw err; - var invocationLine = 'ts.executeCommandLine(sys.args);'; + var invocationLine = 'ts.executeCommandLine(ts.sys.args);'; var index1 = tscContent.indexOf(invocationLine); + if (index1 < 0) { + throw new Error("Could not find " + invocationLine); + } + var index2 = index1 + invocationLine.length; var newContent = tscContent.substr(0, index1) + loggerContent + prepareCode + invocationLine + cleanupCode + tscContent.substr(index2) + '\r\n'; fs.writeFile(tscPath, newContent); diff --git a/src/harness/rwcRunner.ts b/src/harness/rwcRunner.ts index 085f66f1a3e..b506cdd66b6 100644 --- a/src/harness/rwcRunner.ts +++ b/src/harness/rwcRunner.ts @@ -28,6 +28,7 @@ module RWC { var compilerOptions: ts.CompilerOptions; var baselineOpts: Harness.Baseline.BaselineOptions = { Subfolder: 'rwc' }; var baseName = /(.*)\/(.*).json/.exec(ts.normalizeSlashes(jsonPath))[2]; + var currentDirectory: string; after(() => { // Mocha holds onto the closure environment of the describe callback even after the test is done. @@ -38,6 +39,7 @@ module RWC { compilerOptions = undefined; baselineOpts = undefined; baseName = undefined; + currentDirectory = undefined; }); it('can compile', () => { @@ -45,6 +47,7 @@ module RWC { var opts: ts.ParsedCommandLine; var ioLog: IOLog = JSON.parse(Harness.IO.readFile(jsonPath)); + currentDirectory = ioLog.currentDirectory; runWithIOLog(ioLog, () => { opts = ts.parseCommandLine(ioLog.arguments); assert.equal(opts.errors.length, 0); @@ -52,7 +55,6 @@ module RWC { runWithIOLog(ioLog, () => { harnessCompiler.reset(); - // Load the files ts.forEach(opts.filenames, fileName => { inputFiles.push(getHarnessCompilerInputUnit(fileName)); @@ -81,7 +83,11 @@ module RWC { // Emit the results compilerOptions = harnessCompiler.compileFiles(inputFiles, otherFiles, compileResult => { compilerResult = compileResult; - }, /*settingsCallback*/ undefined, opts.options); + }, + /*settingsCallback*/ undefined, opts.options, + // Since all Rwc json file specified current directory in its json file, we need to pass this information to compilerHost + // so that when the host is asked for current directory, it should give the value from json rather than from process + currentDirectory); }); function getHarnessCompilerInputUnit(fileName: string) { @@ -145,7 +151,8 @@ module RWC { it('has the expected errors in generated declaration files', () => { if (compilerOptions.declaration && !compilerResult.errors.length) { Harness.Baseline.runBaseline('has the expected errors in generated declaration files', baseName + '.dts.errors.txt', () => { - var declFileCompilationResult = Harness.Compiler.getCompiler().compileDeclarationFiles(inputFiles, otherFiles, compilerResult, /*settingscallback*/ undefined, compilerOptions); + var declFileCompilationResult = Harness.Compiler.getCompiler().compileDeclarationFiles(inputFiles, otherFiles, compilerResult, + /*settingscallback*/ undefined, compilerOptions, currentDirectory); if (declFileCompilationResult.declResult.errors.length === 0) { return null; } diff --git a/src/services/compiler/tsc.ts b/src/services/compiler/tsc.ts index e77ea9467ca..acd4fb40e6a 100644 --- a/src/services/compiler/tsc.ts +++ b/src/services/compiler/tsc.ts @@ -413,7 +413,7 @@ module TypeScript { opts.flag('noImplicitAny', { usage: { - locCode: DiagnosticCode.Warn_on_expressions_and_declarations_with_an_implied_any_type, + locCode: DiagnosticCode.Raise_error_on_expressions_and_declarations_with_an_implied_any_type, args: null }, set: () => { diff --git a/src/services/core/timer.ts b/src/services/core/timer.ts deleted file mode 100644 index 7d6e3b0784e..00000000000 --- a/src/services/core/timer.ts +++ /dev/null @@ -1,52 +0,0 @@ -/// - -var global: any = Function("return this").call(null); - -module TypeScript { - module Clock { - export var now: () => number; - export var resolution: number; - - declare module WScript { - export function InitializeProjection(): void; - } - - declare module TestUtilities { - export function QueryPerformanceCounter(): number; - export function QueryPerformanceFrequency(): number; - } - - if (typeof WScript !== "undefined" && typeof global['WScript'].InitializeProjection !== "undefined") { - // Running in JSHost. - global['WScript'].InitializeProjection(); - - now = function () { - return TestUtilities.QueryPerformanceCounter(); - }; - - resolution = TestUtilities.QueryPerformanceFrequency(); - } - else { - now = function () { - return Date.now(); - }; - - resolution = 1000; - } - } - - export class Timer { - public startTime: number; - public time = 0; - - public start() { - this.time = 0; - this.startTime = Clock.now(); - } - - public end() { - // Set time to MS. - this.time = (Clock.now() - this.startTime); - } - } -} \ No newline at end of file diff --git a/src/services/formatting/formatting.ts b/src/services/formatting/formatting.ts index b5edf776d58..787c6fe3f46 100644 --- a/src/services/formatting/formatting.ts +++ b/src/services/formatting/formatting.ts @@ -68,7 +68,9 @@ module ts.formatting { export function formatOnEnter(position: number, sourceFile: SourceFile, rulesProvider: RulesProvider, options: FormatCodeOptions): TextChange[] { var line = sourceFile.getLineAndCharacterFromPosition(position).line; - Debug.assert(line >= 2); + if (line === 1) { + return []; + } // get the span for the previous\current line var span = { // get start position for the previous line @@ -597,7 +599,11 @@ module ts.formatting { if (listEndToken !== SyntaxKind.Unknown) { if (formattingScanner.isOnToken()) { var tokenInfo = formattingScanner.readTokenInfo(parent); - if (tokenInfo.token.kind === listEndToken) { + // consume the list end token only if it is still belong to the parent + // there might be the case when current token matches end token but does not considered as one + // function (x: function) <-- + // without this check close paren will be interpreted as list end token for function expression which is wrong + if (tokenInfo.token.kind === listEndToken && rangeContainsRange(parent, tokenInfo.token)) { // consume list end token consumeTokenAndAdvanceScanner(tokenInfo, parent, listDynamicIndentation); } diff --git a/src/services/resources/diagnosticCode.generated.ts b/src/services/resources/diagnosticCode.generated.ts index 03c4efea480..86509fdd63b 100644 --- a/src/services/resources/diagnosticCode.generated.ts +++ b/src/services/resources/diagnosticCode.generated.ts @@ -436,7 +436,7 @@ module TypeScript { This_version_of_the_Javascript_runtime_does_not_support_the_0_function: "This version of the Javascript runtime does not support the '{0}' function.", Unknown_rule: "Unknown rule.", Invalid_line_number_0: "Invalid line number ({0})", - Warn_on_expressions_and_declarations_with_an_implied_any_type: "Warn on expressions and declarations with an implied 'any' type.", + Raise_error_on_expressions_and_declarations_with_an_implied_any_type: "Raise error on expressions and declarations with an implied 'any' type.", Variable_0_implicitly_has_an_any_type: "Variable '{0}' implicitly has an 'any' type.", Parameter_0_of_1_implicitly_has_an_any_type: "Parameter '{0}' of '{1}' implicitly has an 'any' type.", Parameter_0_of_function_type_implicitly_has_an_any_type: "Parameter '{0}' of function type implicitly has an 'any' type.", diff --git a/src/services/resources/diagnosticMessages.json b/src/services/resources/diagnosticMessages.json index 54ecbb75370..60a0bb48df9 100644 --- a/src/services/resources/diagnosticMessages.json +++ b/src/services/resources/diagnosticMessages.json @@ -1743,7 +1743,7 @@ "category": "Error", "code": 7003 }, - "Warn on expressions and declarations with an implied 'any' type.": { + "Raise error on expressions and declarations with an implied 'any' type.": { "category": "Message", "code": 7004 }, diff --git a/src/services/services.ts b/src/services/services.ts index dfca8aea745..7ebf21abc1d 100644 --- a/src/services/services.ts +++ b/src/services/services.ts @@ -852,6 +852,7 @@ module ts { // export interface LanguageServiceHost extends Logger { getCompilationSettings(): CompilerOptions; + getNewLine?(): string; getScriptFileNames(): string[]; getScriptVersion(fileName: string): string; getScriptIsOpen(fileName: string): boolean; @@ -1963,7 +1964,9 @@ module ts { getCancellationToken: () => cancellationToken, getCanonicalFileName: (filename) => useCaseSensitivefilenames ? filename : filename.toLowerCase(), useCaseSensitiveFileNames: () => useCaseSensitivefilenames, - getNewLine: () => "\r\n", + getNewLine: () => { + return host.getNewLine ? host.getNewLine() : "\r\n"; + }, getDefaultLibFilename: (options): string => { return host.getDefaultLibFilename(options); }, diff --git a/src/services/syntax/SyntaxGenerator.d.ts b/src/services/syntax/SyntaxGenerator.d.ts index 4a833f07587..d01d227b786 100644 --- a/src/services/syntax/SyntaxGenerator.d.ts +++ b/src/services/syntax/SyntaxGenerator.d.ts @@ -417,7 +417,7 @@ declare module TypeScript { This_version_of_the_Javascript_runtime_does_not_support_the_0_function: string; Unknown_rule: string; Invalid_line_number_0: string; - Warn_on_expressions_and_declarations_with_an_implied_any_type: string; + Raise_error_on_expressions_and_declarations_with_an_implied_any_type: string; Variable_0_implicitly_has_an_any_type: string; Parameter_0_of_1_implicitly_has_an_any_type: string; Parameter_0_of_function_type_implicitly_has_an_any_type: string; diff --git a/tests/baselines/reference/TypeGuardWithArrayUnion.js b/tests/baselines/reference/TypeGuardWithArrayUnion.js new file mode 100644 index 00000000000..cf98d2c2453 --- /dev/null +++ b/tests/baselines/reference/TypeGuardWithArrayUnion.js @@ -0,0 +1,23 @@ +//// [TypeGuardWithArrayUnion.ts] +class Message { + value: string; +} + +function saySize(message: Message | Message[]) { + if (message instanceof Array) { + return message.length; // Should have type Message[] here + } +} + + +//// [TypeGuardWithArrayUnion.js] +var Message = (function () { + function Message() { + } + return Message; +})(); +function saySize(message) { + if (message instanceof Array) { + return message.length; // Should have type Message[] here + } +} diff --git a/tests/baselines/reference/TypeGuardWithArrayUnion.types b/tests/baselines/reference/TypeGuardWithArrayUnion.types new file mode 100644 index 00000000000..557e305ef74 --- /dev/null +++ b/tests/baselines/reference/TypeGuardWithArrayUnion.types @@ -0,0 +1,26 @@ +=== tests/cases/conformance/expressions/typeGuards/TypeGuardWithArrayUnion.ts === +class Message { +>Message : Message + + value: string; +>value : string +} + +function saySize(message: Message | Message[]) { +>saySize : (message: Message | Message[]) => number +>message : Message | Message[] +>Message : Message +>Message : Message + + if (message instanceof Array) { +>message instanceof Array : boolean +>message : Message | Message[] +>Array : ArrayConstructor + + return message.length; // Should have type Message[] here +>message.length : number +>message : Message[] +>length : number + } +} + diff --git a/tests/baselines/reference/castTest.types b/tests/baselines/reference/castTest.types index 501ff5a3cbe..8250bec362d 100644 --- a/tests/baselines/reference/castTest.types +++ b/tests/baselines/reference/castTest.types @@ -65,8 +65,8 @@ var p_cast = ({ >p_cast : Point > ({ x: 0, y: 0, add: function(dx, dy) { return new Point(this.x + dx, this.y + dy); }, mult: function(p) { return p; }}) : Point >Point : Point ->({ x: 0, y: 0, add: function(dx, dy) { return new Point(this.x + dx, this.y + dy); }, mult: function(p) { return p; }}) : { x: number; y: number; add: (dx: any, dy: any) => Point; mult: (p: any) => any; } ->{ x: 0, y: 0, add: function(dx, dy) { return new Point(this.x + dx, this.y + dy); }, mult: function(p) { return p; }} : { x: number; y: number; add: (dx: any, dy: any) => Point; mult: (p: any) => any; } +>({ x: 0, y: 0, add: function(dx, dy) { return new Point(this.x + dx, this.y + dy); }, mult: function(p) { return p; }}) : { x: number; y: number; add: (dx: number, dy: number) => Point; mult: (p: Point) => Point; } +>{ x: 0, y: 0, add: function(dx, dy) { return new Point(this.x + dx, this.y + dy); }, mult: function(p) { return p; }} : { x: number; y: number; add: (dx: number, dy: number) => Point; mult: (p: Point) => Point; } x: 0, >x : number @@ -75,10 +75,10 @@ var p_cast = ({ >y : number add: function(dx, dy) { ->add : (dx: any, dy: any) => Point ->function(dx, dy) { return new Point(this.x + dx, this.y + dy); } : (dx: any, dy: any) => Point ->dx : any ->dy : any +>add : (dx: number, dy: number) => Point +>function(dx, dy) { return new Point(this.x + dx, this.y + dy); } : (dx: number, dy: number) => Point +>dx : number +>dy : number return new Point(this.x + dx, this.y + dy); >new Point(this.x + dx, this.y + dy) : Point @@ -87,19 +87,19 @@ var p_cast = ({ >this.x : any >this : any >x : any ->dx : any +>dx : number >this.y + dy : any >this.y : any >this : any >y : any ->dy : any +>dy : number }, mult: function(p) { return p; } ->mult : (p: any) => any ->function(p) { return p; } : (p: any) => any ->p : any ->p : any +>mult : (p: Point) => Point +>function(p) { return p; } : (p: Point) => Point +>p : Point +>p : Point }) diff --git a/tests/baselines/reference/constEnumBadPropertyNames.errors.txt b/tests/baselines/reference/constEnumBadPropertyNames.errors.txt new file mode 100644 index 00000000000..7cccf86b1c8 --- /dev/null +++ b/tests/baselines/reference/constEnumBadPropertyNames.errors.txt @@ -0,0 +1,8 @@ +tests/cases/compiler/constEnumBadPropertyNames.ts(2,11): error TS4088: Property 'B' does not exist on 'const' enum 'E'. + + +==== tests/cases/compiler/constEnumBadPropertyNames.ts (1 errors) ==== + const enum E { A } + var x = E["B"] + ~~~ +!!! error TS4088: Property 'B' does not exist on 'const' enum 'E'. \ No newline at end of file diff --git a/tests/baselines/reference/constEnumErrors.errors.txt b/tests/baselines/reference/constEnumErrors.errors.txt index 541f814af98..53fed12f382 100644 --- a/tests/baselines/reference/constEnumErrors.errors.txt +++ b/tests/baselines/reference/constEnumErrors.errors.txt @@ -3,8 +3,8 @@ tests/cases/compiler/constEnumErrors.ts(5,8): error TS2300: Duplicate identifier tests/cases/compiler/constEnumErrors.ts(12,9): error TS4083: In 'const' enum declarations member initializer must be constant expression. tests/cases/compiler/constEnumErrors.ts(14,9): error TS4083: In 'const' enum declarations member initializer must be constant expression. tests/cases/compiler/constEnumErrors.ts(15,10): error TS4083: In 'const' enum declarations member initializer must be constant expression. -tests/cases/compiler/constEnumErrors.ts(22,13): error TS4085: Index expression arguments in 'const' enums must be of type 'string'. -tests/cases/compiler/constEnumErrors.ts(24,13): error TS4085: Index expression arguments in 'const' enums must be of type 'string'. +tests/cases/compiler/constEnumErrors.ts(22,13): error TS4085: A const enum member can only be accessed using a string literal. +tests/cases/compiler/constEnumErrors.ts(24,13): error TS4085: A const enum member can only be accessed using a string literal. tests/cases/compiler/constEnumErrors.ts(26,9): error TS4084: 'const' enums can only be used in property or index access expressions or the right hand side of an import declaration or export assignment. tests/cases/compiler/constEnumErrors.ts(27,10): error TS4084: 'const' enums can only be used in property or index access expressions or the right hand side of an import declaration or export assignment. tests/cases/compiler/constEnumErrors.ts(32,5): error TS4084: 'const' enums can only be used in property or index access expressions or the right hand side of an import declaration or export assignment. @@ -47,11 +47,11 @@ tests/cases/compiler/constEnumErrors.ts(42,9): error TS4087: 'const' enum member var y0 = E2[1] ~ -!!! error TS4085: Index expression arguments in 'const' enums must be of type 'string'. +!!! error TS4085: A const enum member can only be accessed using a string literal. var name = "A"; var y1 = E2[name]; ~~~~ -!!! error TS4085: Index expression arguments in 'const' enums must be of type 'string'. +!!! error TS4085: A const enum member can only be accessed using a string literal. var x = E2; ~~ diff --git a/tests/baselines/reference/contextualTypingWithFixedTypeParameters1.errors.txt b/tests/baselines/reference/contextualTypingWithFixedTypeParameters1.errors.txt index 972b4bb9188..adfb1c68b7a 100644 --- a/tests/baselines/reference/contextualTypingWithFixedTypeParameters1.errors.txt +++ b/tests/baselines/reference/contextualTypingWithFixedTypeParameters1.errors.txt @@ -1,9 +1,17 @@ tests/cases/compiler/contextualTypingWithFixedTypeParameters1.ts(2,22): error TS2339: Property 'foo' does not exist on type 'string'. +tests/cases/compiler/contextualTypingWithFixedTypeParameters1.ts(3,10): error TS2453: The type argument for type parameter 'T' cannot be inferred from the usage. Consider specifying the type arguments explicitly. + Type argument candidate 'string' is not a valid type argument because it is not a supertype of candidate 'T'. +tests/cases/compiler/contextualTypingWithFixedTypeParameters1.ts(3,32): error TS2339: Property 'foo' does not exist on type 'T'. -==== tests/cases/compiler/contextualTypingWithFixedTypeParameters1.ts (1 errors) ==== +==== tests/cases/compiler/contextualTypingWithFixedTypeParameters1.ts (3 errors) ==== var f10: (x: T, b: () => (a: T) => void, y: T) => T; f10('', () => a => a.foo, ''); // a is string ~~~ !!! error TS2339: Property 'foo' does not exist on type 'string'. - var r9 = f10('', () => (a => a.foo), 1); // error \ No newline at end of file + var r9 = f10('', () => (a => a.foo), 1); // error + ~~~ +!!! error TS2453: The type argument for type parameter 'T' cannot be inferred from the usage. Consider specifying the type arguments explicitly. +!!! error TS2453: Type argument candidate 'string' is not a valid type argument because it is not a supertype of candidate 'T'. + ~~~ +!!! error TS2339: Property 'foo' does not exist on type 'T'. \ No newline at end of file diff --git a/tests/baselines/reference/destructuringParameterProperties1.errors.txt b/tests/baselines/reference/destructuringParameterProperties1.errors.txt new file mode 100644 index 00000000000..b8f3a22b4c5 --- /dev/null +++ b/tests/baselines/reference/destructuringParameterProperties1.errors.txt @@ -0,0 +1,71 @@ +tests/cases/conformance/es6/destructuring/destructuringParameterProperties1.ts(2,17): error TS1187: A parameter property may not be a binding pattern. +tests/cases/conformance/es6/destructuring/destructuringParameterProperties1.ts(9,17): error TS1187: A parameter property may not be a binding pattern. +tests/cases/conformance/es6/destructuring/destructuringParameterProperties1.ts(16,17): error TS1187: A parameter property may not be a binding pattern. +tests/cases/conformance/es6/destructuring/destructuringParameterProperties1.ts(22,26): error TS2339: Property 'x' does not exist on type 'C1'. +tests/cases/conformance/es6/destructuring/destructuringParameterProperties1.ts(22,35): error TS2339: Property 'y' does not exist on type 'C1'. +tests/cases/conformance/es6/destructuring/destructuringParameterProperties1.ts(22,43): error TS2339: Property 'y' does not exist on type 'C1'. +tests/cases/conformance/es6/destructuring/destructuringParameterProperties1.ts(22,52): error TS2339: Property 'z' does not exist on type 'C1'. +tests/cases/conformance/es6/destructuring/destructuringParameterProperties1.ts(25,30): error TS2339: Property 'x' does not exist on type 'C2'. +tests/cases/conformance/es6/destructuring/destructuringParameterProperties1.ts(25,36): error TS2339: Property 'y' does not exist on type 'C2'. +tests/cases/conformance/es6/destructuring/destructuringParameterProperties1.ts(25,42): error TS2339: Property 'z' does not exist on type 'C2'. +tests/cases/conformance/es6/destructuring/destructuringParameterProperties1.ts(29,30): error TS2339: Property 'x' does not exist on type 'C3'. +tests/cases/conformance/es6/destructuring/destructuringParameterProperties1.ts(29,36): error TS2339: Property 'y' does not exist on type 'C3'. +tests/cases/conformance/es6/destructuring/destructuringParameterProperties1.ts(29,42): error TS2339: Property 'z' does not exist on type 'C3'. + + +==== tests/cases/conformance/es6/destructuring/destructuringParameterProperties1.ts (13 errors) ==== + class C1 { + constructor(public [x, y, z]: string[]) { + ~~~~~~~~~~~~~~~~~~~~~~~~~~ +!!! error TS1187: A parameter property may not be a binding pattern. + } + } + + type TupleType1 = [string, number, boolean]; + + class C2 { + constructor(public [x, y, z]: TupleType1) { + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +!!! error TS1187: A parameter property may not be a binding pattern. + } + } + + type ObjType1 = { x: number; y: string; z: boolean } + + class C3 { + constructor(public { x, y, z }: ObjType1) { + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +!!! error TS1187: A parameter property may not be a binding pattern. + } + } + + var c1 = new C1([]); + c1 = new C1(["larry", "{curly}", "moe"]); + var useC1Properties = c1.x === c1.y && c1.y === c1.z; + ~ +!!! error TS2339: Property 'x' does not exist on type 'C1'. + ~ +!!! error TS2339: Property 'y' does not exist on type 'C1'. + ~ +!!! error TS2339: Property 'y' does not exist on type 'C1'. + ~ +!!! error TS2339: Property 'z' does not exist on type 'C1'. + + var c2 = new C2(["10", 10, !!10]); + var [c2_x, c2_y, c2_z] = [c2.x, c2.y, c2.z]; + ~ +!!! error TS2339: Property 'x' does not exist on type 'C2'. + ~ +!!! error TS2339: Property 'y' does not exist on type 'C2'. + ~ +!!! error TS2339: Property 'z' does not exist on type 'C2'. + + var c3 = new C3({x: 0, y: "", z: false}); + c3 = new C3({x: 0, "y": "y", z: true}); + var [c3_x, c3_y, c3_z] = [c3.x, c3.y, c3.z]; + ~ +!!! error TS2339: Property 'x' does not exist on type 'C3'. + ~ +!!! error TS2339: Property 'y' does not exist on type 'C3'. + ~ +!!! error TS2339: Property 'z' does not exist on type 'C3'. \ No newline at end of file diff --git a/tests/baselines/reference/destructuringParameterProperties1.js b/tests/baselines/reference/destructuringParameterProperties1.js new file mode 100644 index 00000000000..cc16cc78de5 --- /dev/null +++ b/tests/baselines/reference/destructuringParameterProperties1.js @@ -0,0 +1,61 @@ +//// [destructuringParameterProperties1.ts] +class C1 { + constructor(public [x, y, z]: string[]) { + } +} + +type TupleType1 = [string, number, boolean]; + +class C2 { + constructor(public [x, y, z]: TupleType1) { + } +} + +type ObjType1 = { x: number; y: string; z: boolean } + +class C3 { + constructor(public { x, y, z }: ObjType1) { + } +} + +var c1 = new C1([]); +c1 = new C1(["larry", "{curly}", "moe"]); +var useC1Properties = c1.x === c1.y && c1.y === c1.z; + +var c2 = new C2(["10", 10, !!10]); +var [c2_x, c2_y, c2_z] = [c2.x, c2.y, c2.z]; + +var c3 = new C3({x: 0, y: "", z: false}); +c3 = new C3({x: 0, "y": "y", z: true}); +var [c3_x, c3_y, c3_z] = [c3.x, c3.y, c3.z]; + +//// [destructuringParameterProperties1.js] +var C1 = (function () { + function C1(_a) { + var x = _a[0], y = _a[1], z = _a[2]; + this.[x, y, z] = [x, y, z]; + } + return C1; +})(); +var C2 = (function () { + function C2(_a) { + var x = _a[0], y = _a[1], z = _a[2]; + this.[x, y, z] = [x, y, z]; + } + return C2; +})(); +var C3 = (function () { + function C3(_a) { + var x = _a.x, y = _a.y, z = _a.z; + this.{ x, y, z } = { x, y, z }; + } + return C3; +})(); +var c1 = new C1([]); +c1 = new C1(["larry", "{curly}", "moe"]); +var useC1Properties = c1.x === c1.y && c1.y === c1.z; +var c2 = new C2(["10", 10, !!10]); +var _a = [c2.x, c2.y, c2.z], c2_x = _a[0], c2_y = _a[1], c2_z = _a[2]; +var c3 = new C3({ x: 0, y: "", z: false }); +c3 = new C3({ x: 0, "y": "y", z: true }); +var _b = [c3.x, c3.y, c3.z], c3_x = _b[0], c3_y = _b[1], c3_z = _b[2]; diff --git a/tests/baselines/reference/destructuringParameterProperties2.errors.txt b/tests/baselines/reference/destructuringParameterProperties2.errors.txt new file mode 100644 index 00000000000..61c0e61611a --- /dev/null +++ b/tests/baselines/reference/destructuringParameterProperties2.errors.txt @@ -0,0 +1,56 @@ +tests/cases/conformance/es6/destructuring/destructuringParameterProperties2.ts(2,36): error TS1187: A parameter property may not be a binding pattern. +tests/cases/conformance/es6/destructuring/destructuringParameterProperties2.ts(3,59): error TS2339: Property 'b' does not exist on type 'C1'. +tests/cases/conformance/es6/destructuring/destructuringParameterProperties2.ts(3,83): error TS2339: Property 'c' does not exist on type 'C1'. +tests/cases/conformance/es6/destructuring/destructuringParameterProperties2.ts(4,18): error TS2339: Property 'a' does not exist on type 'C1'. +tests/cases/conformance/es6/destructuring/destructuringParameterProperties2.ts(9,21): error TS2339: Property 'a' does not exist on type 'C1'. +tests/cases/conformance/es6/destructuring/destructuringParameterProperties2.ts(13,21): error TS2339: Property 'b' does not exist on type 'C1'. +tests/cases/conformance/es6/destructuring/destructuringParameterProperties2.ts(17,21): error TS2339: Property 'c' does not exist on type 'C1'. +tests/cases/conformance/es6/destructuring/destructuringParameterProperties2.ts(21,27): error TS2345: Argument of type '[number, undefined, string]' is not assignable to parameter of type '[number, string, boolean]'. + + +==== tests/cases/conformance/es6/destructuring/destructuringParameterProperties2.ts (8 errors) ==== + class C1 { + constructor(private k: number, private [a, b, c]: [number, string, boolean]) { + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +!!! error TS1187: A parameter property may not be a binding pattern. + if ((b === undefined && c === undefined) || (this.b === undefined && this.c === undefined)) { + ~ +!!! error TS2339: Property 'b' does not exist on type 'C1'. + ~ +!!! error TS2339: Property 'c' does not exist on type 'C1'. + this.a = a || k; + ~ +!!! error TS2339: Property 'a' does not exist on type 'C1'. + } + } + + public getA() { + return this.a + ~ +!!! error TS2339: Property 'a' does not exist on type 'C1'. + } + + public getB() { + return this.b + ~ +!!! error TS2339: Property 'b' does not exist on type 'C1'. + } + + public getC() { + return this.c; + ~ +!!! error TS2339: Property 'c' does not exist on type 'C1'. + } + } + + var x = new C1(undefined, [0, undefined, ""]); + ~~~~~~~~~~~~~~~~~~ +!!! error TS2345: Argument of type '[number, undefined, string]' is not assignable to parameter of type '[number, string, boolean]'. + var [x_a, x_b, x_c] = [x.getA(), x.getB(), x.getC()]; + + var y = new C1(10, [0, "", true]); + var [y_a, y_b, y_c] = [y.getA(), y.getB(), y.getC()]; + + var z = new C1(10, [undefined, "", null]); + var [z_a, z_b, z_c] = [z.getA(), z.getB(), z.getC()]; + \ No newline at end of file diff --git a/tests/baselines/reference/destructuringParameterProperties2.js b/tests/baselines/reference/destructuringParameterProperties2.js new file mode 100644 index 00000000000..27e190af62f --- /dev/null +++ b/tests/baselines/reference/destructuringParameterProperties2.js @@ -0,0 +1,58 @@ +//// [destructuringParameterProperties2.ts] +class C1 { + constructor(private k: number, private [a, b, c]: [number, string, boolean]) { + if ((b === undefined && c === undefined) || (this.b === undefined && this.c === undefined)) { + this.a = a || k; + } + } + + public getA() { + return this.a + } + + public getB() { + return this.b + } + + public getC() { + return this.c; + } +} + +var x = new C1(undefined, [0, undefined, ""]); +var [x_a, x_b, x_c] = [x.getA(), x.getB(), x.getC()]; + +var y = new C1(10, [0, "", true]); +var [y_a, y_b, y_c] = [y.getA(), y.getB(), y.getC()]; + +var z = new C1(10, [undefined, "", null]); +var [z_a, z_b, z_c] = [z.getA(), z.getB(), z.getC()]; + + +//// [destructuringParameterProperties2.js] +var C1 = (function () { + function C1(k, _a) { + var a = _a[0], b = _a[1], c = _a[2]; + this.k = k; + this.[a, b, c] = [a, b, c]; + if ((b === undefined && c === undefined) || (this.b === undefined && this.c === undefined)) { + this.a = a || k; + } + } + C1.prototype.getA = function () { + return this.a; + }; + C1.prototype.getB = function () { + return this.b; + }; + C1.prototype.getC = function () { + return this.c; + }; + return C1; +})(); +var x = new C1(undefined, [0, undefined, ""]); +var _a = [x.getA(), x.getB(), x.getC()], x_a = _a[0], x_b = _a[1], x_c = _a[2]; +var y = new C1(10, [0, "", true]); +var _b = [y.getA(), y.getB(), y.getC()], y_a = _b[0], y_b = _b[1], y_c = _b[2]; +var z = new C1(10, [undefined, "", null]); +var _c = [z.getA(), z.getB(), z.getC()], z_a = _c[0], z_b = _c[1], z_c = _c[2]; diff --git a/tests/baselines/reference/destructuringParameterProperties3.errors.txt b/tests/baselines/reference/destructuringParameterProperties3.errors.txt new file mode 100644 index 00000000000..73d7dab2a38 --- /dev/null +++ b/tests/baselines/reference/destructuringParameterProperties3.errors.txt @@ -0,0 +1,56 @@ +tests/cases/conformance/es6/destructuring/destructuringParameterProperties3.ts(2,31): error TS1187: A parameter property may not be a binding pattern. +tests/cases/conformance/es6/destructuring/destructuringParameterProperties3.ts(3,59): error TS2339: Property 'b' does not exist on type 'C1'. +tests/cases/conformance/es6/destructuring/destructuringParameterProperties3.ts(3,83): error TS2339: Property 'c' does not exist on type 'C1'. +tests/cases/conformance/es6/destructuring/destructuringParameterProperties3.ts(4,18): error TS2339: Property 'a' does not exist on type 'C1'. +tests/cases/conformance/es6/destructuring/destructuringParameterProperties3.ts(9,21): error TS2339: Property 'a' does not exist on type 'C1'. +tests/cases/conformance/es6/destructuring/destructuringParameterProperties3.ts(13,21): error TS2339: Property 'b' does not exist on type 'C1'. +tests/cases/conformance/es6/destructuring/destructuringParameterProperties3.ts(17,21): error TS2339: Property 'c' does not exist on type 'C1'. + + +==== tests/cases/conformance/es6/destructuring/destructuringParameterProperties3.ts (7 errors) ==== + class C1 { + constructor(private k: T, private [a, b, c]: [T,U,V]) { + ~~~~~~~~~~~~~~~~~~~~~~~~~~ +!!! error TS1187: A parameter property may not be a binding pattern. + if ((b === undefined && c === undefined) || (this.b === undefined && this.c === undefined)) { + ~ +!!! error TS2339: Property 'b' does not exist on type 'C1'. + ~ +!!! error TS2339: Property 'c' does not exist on type 'C1'. + this.a = a || k; + ~ +!!! error TS2339: Property 'a' does not exist on type 'C1'. + } + } + + public getA() { + return this.a + ~ +!!! error TS2339: Property 'a' does not exist on type 'C1'. + } + + public getB() { + return this.b + ~ +!!! error TS2339: Property 'b' does not exist on type 'C1'. + } + + public getC() { + return this.c; + ~ +!!! error TS2339: Property 'c' does not exist on type 'C1'. + } + } + + var x = new C1(undefined, [0, true, ""]); + var [x_a, x_b, x_c] = [x.getA(), x.getB(), x.getC()]; + + var y = new C1(10, [0, true, true]); + var [y_a, y_b, y_c] = [y.getA(), y.getB(), y.getC()]; + + var z = new C1(10, [undefined, "", ""]); + var [z_a, z_b, z_c] = [z.getA(), z.getB(), z.getC()]; + + var w = new C1(10, [undefined, undefined, undefined]); + var [z_a, z_b, z_c] = [z.getA(), z.getB(), z.getC()]; + \ No newline at end of file diff --git a/tests/baselines/reference/destructuringParameterProperties3.js b/tests/baselines/reference/destructuringParameterProperties3.js new file mode 100644 index 00000000000..fe9e69d7e5b --- /dev/null +++ b/tests/baselines/reference/destructuringParameterProperties3.js @@ -0,0 +1,63 @@ +//// [destructuringParameterProperties3.ts] +class C1 { + constructor(private k: T, private [a, b, c]: [T,U,V]) { + if ((b === undefined && c === undefined) || (this.b === undefined && this.c === undefined)) { + this.a = a || k; + } + } + + public getA() { + return this.a + } + + public getB() { + return this.b + } + + public getC() { + return this.c; + } +} + +var x = new C1(undefined, [0, true, ""]); +var [x_a, x_b, x_c] = [x.getA(), x.getB(), x.getC()]; + +var y = new C1(10, [0, true, true]); +var [y_a, y_b, y_c] = [y.getA(), y.getB(), y.getC()]; + +var z = new C1(10, [undefined, "", ""]); +var [z_a, z_b, z_c] = [z.getA(), z.getB(), z.getC()]; + +var w = new C1(10, [undefined, undefined, undefined]); +var [z_a, z_b, z_c] = [z.getA(), z.getB(), z.getC()]; + + +//// [destructuringParameterProperties3.js] +var C1 = (function () { + function C1(k, _a) { + var a = _a[0], b = _a[1], c = _a[2]; + this.k = k; + this.[a, b, c] = [a, b, c]; + if ((b === undefined && c === undefined) || (this.b === undefined && this.c === undefined)) { + this.a = a || k; + } + } + C1.prototype.getA = function () { + return this.a; + }; + C1.prototype.getB = function () { + return this.b; + }; + C1.prototype.getC = function () { + return this.c; + }; + return C1; +})(); +var x = new C1(undefined, [0, true, ""]); +var _a = [x.getA(), x.getB(), x.getC()], x_a = _a[0], x_b = _a[1], x_c = _a[2]; +var y = new C1(10, [0, true, true]); +var _b = [y.getA(), y.getB(), y.getC()], y_a = _b[0], y_b = _b[1], y_c = _b[2]; +var z = new C1(10, [undefined, "", ""]); +var _c = [z.getA(), z.getB(), z.getC()], z_a = _c[0], z_b = _c[1], z_c = _c[2]; +var w = new C1(10, [undefined, undefined, undefined]); +var _d = [z.getA(), z.getB(), z.getC()], z_a = _d[0], z_b = _d[1], z_c = _d[2]; diff --git a/tests/baselines/reference/destructuringParameterProperties4.errors.txt b/tests/baselines/reference/destructuringParameterProperties4.errors.txt new file mode 100644 index 00000000000..04f6f82b5df --- /dev/null +++ b/tests/baselines/reference/destructuringParameterProperties4.errors.txt @@ -0,0 +1,60 @@ +tests/cases/conformance/es6/destructuring/destructuringParameterProperties4.ts(3,31): error TS1187: A parameter property may not be a binding pattern. +tests/cases/conformance/es6/destructuring/destructuringParameterProperties4.ts(4,59): error TS2339: Property 'b' does not exist on type 'C1'. +tests/cases/conformance/es6/destructuring/destructuringParameterProperties4.ts(4,83): error TS2339: Property 'c' does not exist on type 'C1'. +tests/cases/conformance/es6/destructuring/destructuringParameterProperties4.ts(5,18): error TS2339: Property 'a' does not exist on type 'C1'. +tests/cases/conformance/es6/destructuring/destructuringParameterProperties4.ts(10,21): error TS2339: Property 'a' does not exist on type 'C1'. +tests/cases/conformance/es6/destructuring/destructuringParameterProperties4.ts(14,21): error TS2339: Property 'b' does not exist on type 'C1'. +tests/cases/conformance/es6/destructuring/destructuringParameterProperties4.ts(18,21): error TS2339: Property 'c' does not exist on type 'C1'. +tests/cases/conformance/es6/destructuring/destructuringParameterProperties4.ts(24,24): error TS2339: Property 'a' does not exist on type 'C2'. +tests/cases/conformance/es6/destructuring/destructuringParameterProperties4.ts(24,34): error TS2339: Property 'b' does not exist on type 'C2'. +tests/cases/conformance/es6/destructuring/destructuringParameterProperties4.ts(24,44): error TS2339: Property 'c' does not exist on type 'C2'. + + +==== tests/cases/conformance/es6/destructuring/destructuringParameterProperties4.ts (10 errors) ==== + + class C1 { + constructor(private k: T, protected [a, b, c]: [T,U,V]) { + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +!!! error TS1187: A parameter property may not be a binding pattern. + if ((b === undefined && c === undefined) || (this.b === undefined && this.c === undefined)) { + ~ +!!! error TS2339: Property 'b' does not exist on type 'C1'. + ~ +!!! error TS2339: Property 'c' does not exist on type 'C1'. + this.a = a || k; + ~ +!!! error TS2339: Property 'a' does not exist on type 'C1'. + } + } + + public getA() { + return this.a + ~ +!!! error TS2339: Property 'a' does not exist on type 'C1'. + } + + public getB() { + return this.b + ~ +!!! error TS2339: Property 'b' does not exist on type 'C1'. + } + + public getC() { + return this.c; + ~ +!!! error TS2339: Property 'c' does not exist on type 'C1'. + } + } + + class C2 extends C1 { + public doSomethingWithSuperProperties() { + return `${this.a} ${this.b} ${this.c}`; + ~ +!!! error TS2339: Property 'a' does not exist on type 'C2'. + ~ +!!! error TS2339: Property 'b' does not exist on type 'C2'. + ~ +!!! error TS2339: Property 'c' does not exist on type 'C2'. + } + } + \ No newline at end of file diff --git a/tests/baselines/reference/destructuringParameterProperties4.js b/tests/baselines/reference/destructuringParameterProperties4.js new file mode 100644 index 00000000000..6da6f53a4fe --- /dev/null +++ b/tests/baselines/reference/destructuringParameterProperties4.js @@ -0,0 +1,65 @@ +//// [destructuringParameterProperties4.ts] + +class C1 { + constructor(private k: T, protected [a, b, c]: [T,U,V]) { + if ((b === undefined && c === undefined) || (this.b === undefined && this.c === undefined)) { + this.a = a || k; + } + } + + public getA() { + return this.a + } + + public getB() { + return this.b + } + + public getC() { + return this.c; + } +} + +class C2 extends C1 { + public doSomethingWithSuperProperties() { + return `${this.a} ${this.b} ${this.c}`; + } +} + + +//// [destructuringParameterProperties4.js] +var __extends = this.__extends || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + __.prototype = b.prototype; + d.prototype = new __(); +}; +var C1 = (function () { + function C1(k, [a, b, c]) { + this.k = k; + this.[a, b, c] = [a, b, c]; + if ((b === undefined && c === undefined) || (this.b === undefined && this.c === undefined)) { + this.a = a || k; + } + } + C1.prototype.getA = function () { + return this.a; + }; + C1.prototype.getB = function () { + return this.b; + }; + C1.prototype.getC = function () { + return this.c; + }; + return C1; +})(); +var C2 = (function (_super) { + __extends(C2, _super); + function C2() { + _super.apply(this, arguments); + } + C2.prototype.doSomethingWithSuperProperties = function () { + return `${this.a} ${this.b} ${this.c}`; + }; + return C2; +})(C1); diff --git a/tests/baselines/reference/destructuringParameterProperties5.errors.txt b/tests/baselines/reference/destructuringParameterProperties5.errors.txt new file mode 100644 index 00000000000..dca02a9a84e --- /dev/null +++ b/tests/baselines/reference/destructuringParameterProperties5.errors.txt @@ -0,0 +1,51 @@ +tests/cases/conformance/es6/destructuring/destructuringParameterProperties5.ts(5,17): error TS1187: A parameter property may not be a binding pattern. +tests/cases/conformance/es6/destructuring/destructuringParameterProperties5.ts(5,27): error TS2459: Type '{ x: number; y: string; z: boolean; }' has no property 'x1' and no string index signature. +tests/cases/conformance/es6/destructuring/destructuringParameterProperties5.ts(5,31): error TS2459: Type '{ x: number; y: string; z: boolean; }' has no property 'x2' and no string index signature. +tests/cases/conformance/es6/destructuring/destructuringParameterProperties5.ts(5,35): error TS2459: Type '{ x: number; y: string; z: boolean; }' has no property 'x3' and no string index signature. +tests/cases/conformance/es6/destructuring/destructuringParameterProperties5.ts(7,29): error TS2339: Property 'x1' does not exist on type 'C1'. +tests/cases/conformance/es6/destructuring/destructuringParameterProperties5.ts(7,40): error TS2339: Property 'x2' does not exist on type 'C1'. +tests/cases/conformance/es6/destructuring/destructuringParameterProperties5.ts(7,51): error TS2339: Property 'x3' does not exist on type 'C1'. +tests/cases/conformance/es6/destructuring/destructuringParameterProperties5.ts(7,62): error TS2339: Property 'y' does not exist on type 'C1'. +tests/cases/conformance/es6/destructuring/destructuringParameterProperties5.ts(7,72): error TS2339: Property 'z' does not exist on type 'C1'. +tests/cases/conformance/es6/destructuring/destructuringParameterProperties5.ts(11,16): error TS2345: Argument of type '[{ x1: number; x2: string; x3: boolean; }, string, boolean]' is not assignable to parameter of type '[{ x: number; y: string; z: boolean; }, number, string]'. + Types of property '0' are incompatible. + Type '{ x1: number; x2: string; x3: boolean; }' is not assignable to type '{ x: number; y: string; z: boolean; }'. + Property 'x' is missing in type '{ x1: number; x2: string; x3: boolean; }'. + + +==== tests/cases/conformance/es6/destructuring/destructuringParameterProperties5.ts (10 errors) ==== + type ObjType1 = { x: number; y: string; z: boolean } + type TupleType1 = [ObjType1, number, string] + + class C1 { + constructor(public [{ x1, x2, x3 }, y, z]: TupleType1) { + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +!!! error TS1187: A parameter property may not be a binding pattern. + ~~ +!!! error TS2459: Type '{ x: number; y: string; z: boolean; }' has no property 'x1' and no string index signature. + ~~ +!!! error TS2459: Type '{ x: number; y: string; z: boolean; }' has no property 'x2' and no string index signature. + ~~ +!!! error TS2459: Type '{ x: number; y: string; z: boolean; }' has no property 'x3' and no string index signature. + var foo: any = x1 || x2 || x3 || y || z; + var bar: any = this.x1 || this.x2 || this.x3 || this.y || this.z; + ~~ +!!! error TS2339: Property 'x1' does not exist on type 'C1'. + ~~ +!!! error TS2339: Property 'x2' does not exist on type 'C1'. + ~~ +!!! error TS2339: Property 'x3' does not exist on type 'C1'. + ~ +!!! error TS2339: Property 'y' does not exist on type 'C1'. + ~ +!!! error TS2339: Property 'z' does not exist on type 'C1'. + } + } + + var a = new C1([{ x1: 10, x2: "", x3: true }, "", false]); + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +!!! error TS2345: Argument of type '[{ x1: number; x2: string; x3: boolean; }, string, boolean]' is not assignable to parameter of type '[{ x: number; y: string; z: boolean; }, number, string]'. +!!! error TS2345: Types of property '0' are incompatible. +!!! error TS2345: Type '{ x1: number; x2: string; x3: boolean; }' is not assignable to type '{ x: number; y: string; z: boolean; }'. +!!! error TS2345: Property 'x' is missing in type '{ x1: number; x2: string; x3: boolean; }'. + var [a_x1, a_x2, a_x3, a_y, a_z] = [a.x1, a.x2, a.x3, a.y, a.z]; \ No newline at end of file diff --git a/tests/baselines/reference/destructuringParameterProperties5.js b/tests/baselines/reference/destructuringParameterProperties5.js new file mode 100644 index 00000000000..d9b1710ae89 --- /dev/null +++ b/tests/baselines/reference/destructuringParameterProperties5.js @@ -0,0 +1,26 @@ +//// [destructuringParameterProperties5.ts] +type ObjType1 = { x: number; y: string; z: boolean } +type TupleType1 = [ObjType1, number, string] + +class C1 { + constructor(public [{ x1, x2, x3 }, y, z]: TupleType1) { + var foo: any = x1 || x2 || x3 || y || z; + var bar: any = this.x1 || this.x2 || this.x3 || this.y || this.z; + } +} + +var a = new C1([{ x1: 10, x2: "", x3: true }, "", false]); +var [a_x1, a_x2, a_x3, a_y, a_z] = [a.x1, a.x2, a.x3, a.y, a.z]; + +//// [destructuringParameterProperties5.js] +var C1 = (function () { + function C1(_a) { + var _b = _a[0], x1 = _b.x1, x2 = _b.x2, x3 = _b.x3, y = _a[1], z = _a[2]; + this.[{ x1, x2, x3 }, y, z] = [{ x1, x2, x3 }, y, z]; + var foo = x1 || x2 || x3 || y || z; + var bar = this.x1 || this.x2 || this.x3 || this.y || this.z; + } + return C1; +})(); +var a = new C1([{ x1: 10, x2: "", x3: true }, "", false]); +var _a = [a.x1, a.x2, a.x3, a.y, a.z], a_x1 = _a[0], a_x2 = _a[1], a_x3 = _a[2], a_y = _a[3], a_z = _a[4]; diff --git a/tests/baselines/reference/emitDefaultParametersFunction.js b/tests/baselines/reference/emitDefaultParametersFunction.js new file mode 100644 index 00000000000..6be7ae9dbfe --- /dev/null +++ b/tests/baselines/reference/emitDefaultParametersFunction.js @@ -0,0 +1,27 @@ +//// [emitDefaultParametersFunction.ts] +function foo(x: string, y = 10) { } +function baz(x: string, y = 5, ...rest) { } +function bar(y = 10) { } +function bar1(y = 10, ...rest) { } + +//// [emitDefaultParametersFunction.js] +function foo(x, y) { + if (y === void 0) { y = 10; } +} +function baz(x, y) { + if (y === void 0) { y = 5; } + var rest = []; + for (var _i = 2; _i < arguments.length; _i++) { + rest[_i - 2] = arguments[_i]; + } +} +function bar(y) { + if (y === void 0) { y = 10; } +} +function bar1(y) { + if (y === void 0) { y = 10; } + var rest = []; + for (var _i = 1; _i < arguments.length; _i++) { + rest[_i - 1] = arguments[_i]; + } +} diff --git a/tests/baselines/reference/emitDefaultParametersFunction.types b/tests/baselines/reference/emitDefaultParametersFunction.types new file mode 100644 index 00000000000..a8dec6335a9 --- /dev/null +++ b/tests/baselines/reference/emitDefaultParametersFunction.types @@ -0,0 +1,21 @@ +=== tests/cases/conformance/es6/defaultParameters/emitDefaultParametersFunction.ts === +function foo(x: string, y = 10) { } +>foo : (x: string, y?: number) => void +>x : string +>y : number + +function baz(x: string, y = 5, ...rest) { } +>baz : (x: string, y?: number, ...rest: any[]) => void +>x : string +>y : number +>rest : any[] + +function bar(y = 10) { } +>bar : (y?: number) => void +>y : number + +function bar1(y = 10, ...rest) { } +>bar1 : (y?: number, ...rest: any[]) => void +>y : number +>rest : any[] + diff --git a/tests/baselines/reference/emitDefaultParametersFunctionES6.js b/tests/baselines/reference/emitDefaultParametersFunctionES6.js new file mode 100644 index 00000000000..f4084a16f6f --- /dev/null +++ b/tests/baselines/reference/emitDefaultParametersFunctionES6.js @@ -0,0 +1,15 @@ +//// [emitDefaultParametersFunctionES6.ts] +function foo(x: string, y = 10) { } +function baz(x: string, y = 5, ...rest) { } +function bar(y = 10) { } +function bar1(y = 10, ...rest) { } + +//// [emitDefaultParametersFunctionES6.js] +function foo(x, y = 10) { +} +function baz(x, y = 5, ...rest) { +} +function bar(y = 10) { +} +function bar1(y = 10, ...rest) { +} diff --git a/tests/baselines/reference/emitDefaultParametersFunctionES6.types b/tests/baselines/reference/emitDefaultParametersFunctionES6.types new file mode 100644 index 00000000000..1c67032264f --- /dev/null +++ b/tests/baselines/reference/emitDefaultParametersFunctionES6.types @@ -0,0 +1,21 @@ +=== tests/cases/conformance/es6/defaultParameters/emitDefaultParametersFunctionES6.ts === +function foo(x: string, y = 10) { } +>foo : (x: string, y?: number) => void +>x : string +>y : number + +function baz(x: string, y = 5, ...rest) { } +>baz : (x: string, y?: number, ...rest: any[]) => void +>x : string +>y : number +>rest : any[] + +function bar(y = 10) { } +>bar : (y?: number) => void +>y : number + +function bar1(y = 10, ...rest) { } +>bar1 : (y?: number, ...rest: any[]) => void +>y : number +>rest : any[] + diff --git a/tests/baselines/reference/emitDefaultParametersFunctionExpression.js b/tests/baselines/reference/emitDefaultParametersFunctionExpression.js new file mode 100644 index 00000000000..bcfe5b240f2 --- /dev/null +++ b/tests/baselines/reference/emitDefaultParametersFunctionExpression.js @@ -0,0 +1,54 @@ +//// [emitDefaultParametersFunctionExpression.ts] +var lambda1 = (y = "hello") => { } +var lambda2 = (x: number, y = "hello") => { } +var lambda3 = (x: number, y = "hello", ...rest) => { } +var lambda4 = (y = "hello", ...rest) => { } + +var x = function (str = "hello", ...rest) { } +var y = (function (num = 10, boo = false, ...rest) { })() +var z = (function (num: number, boo = false, ...rest) { })(10) + + +//// [emitDefaultParametersFunctionExpression.js] +var lambda1 = function (y) { + if (y === void 0) { y = "hello"; } +}; +var lambda2 = function (x, y) { + if (y === void 0) { y = "hello"; } +}; +var lambda3 = function (x, y) { + if (y === void 0) { y = "hello"; } + var rest = []; + for (var _i = 2; _i < arguments.length; _i++) { + rest[_i - 2] = arguments[_i]; + } +}; +var lambda4 = function (y) { + if (y === void 0) { y = "hello"; } + var rest = []; + for (var _i = 1; _i < arguments.length; _i++) { + rest[_i - 1] = arguments[_i]; + } +}; +var x = function (str) { + if (str === void 0) { str = "hello"; } + var rest = []; + for (var _i = 1; _i < arguments.length; _i++) { + rest[_i - 1] = arguments[_i]; + } +}; +var y = (function (num, boo) { + if (num === void 0) { num = 10; } + if (boo === void 0) { boo = false; } + var rest = []; + for (var _i = 2; _i < arguments.length; _i++) { + rest[_i - 2] = arguments[_i]; + } +})(); +var z = (function (num, boo) { + if (boo === void 0) { boo = false; } + var rest = []; + for (var _i = 2; _i < arguments.length; _i++) { + rest[_i - 2] = arguments[_i]; + } +})(10); diff --git a/tests/baselines/reference/emitDefaultParametersFunctionExpression.types b/tests/baselines/reference/emitDefaultParametersFunctionExpression.types new file mode 100644 index 00000000000..5c223ff1344 --- /dev/null +++ b/tests/baselines/reference/emitDefaultParametersFunctionExpression.types @@ -0,0 +1,49 @@ +=== tests/cases/conformance/es6/defaultParameters/emitDefaultParametersFunctionExpression.ts === +var lambda1 = (y = "hello") => { } +>lambda1 : (y?: string) => void +>(y = "hello") => { } : (y?: string) => void +>y : string + +var lambda2 = (x: number, y = "hello") => { } +>lambda2 : (x: number, y?: string) => void +>(x: number, y = "hello") => { } : (x: number, y?: string) => void +>x : number +>y : string + +var lambda3 = (x: number, y = "hello", ...rest) => { } +>lambda3 : (x: number, y?: string, ...rest: any[]) => void +>(x: number, y = "hello", ...rest) => { } : (x: number, y?: string, ...rest: any[]) => void +>x : number +>y : string +>rest : any[] + +var lambda4 = (y = "hello", ...rest) => { } +>lambda4 : (y?: string, ...rest: any[]) => void +>(y = "hello", ...rest) => { } : (y?: string, ...rest: any[]) => void +>y : string +>rest : any[] + +var x = function (str = "hello", ...rest) { } +>x : (str?: string, ...rest: any[]) => void +>function (str = "hello", ...rest) { } : (str?: string, ...rest: any[]) => void +>str : string +>rest : any[] + +var y = (function (num = 10, boo = false, ...rest) { })() +>y : void +>(function (num = 10, boo = false, ...rest) { })() : void +>(function (num = 10, boo = false, ...rest) { }) : (num?: number, boo?: boolean, ...rest: any[]) => void +>function (num = 10, boo = false, ...rest) { } : (num?: number, boo?: boolean, ...rest: any[]) => void +>num : number +>boo : boolean +>rest : any[] + +var z = (function (num: number, boo = false, ...rest) { })(10) +>z : void +>(function (num: number, boo = false, ...rest) { })(10) : void +>(function (num: number, boo = false, ...rest) { }) : (num: number, boo?: boolean, ...rest: any[]) => void +>function (num: number, boo = false, ...rest) { } : (num: number, boo?: boolean, ...rest: any[]) => void +>num : number +>boo : boolean +>rest : any[] + diff --git a/tests/baselines/reference/emitDefaultParametersFunctionExpressionES6.js b/tests/baselines/reference/emitDefaultParametersFunctionExpressionES6.js new file mode 100644 index 00000000000..eabb0e1e344 --- /dev/null +++ b/tests/baselines/reference/emitDefaultParametersFunctionExpressionES6.js @@ -0,0 +1,25 @@ +//// [emitDefaultParametersFunctionExpressionES6.ts] +var lambda1 = (y = "hello") => { } +var lambda2 = (x: number, y = "hello") => { } +var lambda3 = (x: number, y = "hello", ...rest) => { } +var lambda4 = (y = "hello", ...rest) => { } + +var x = function (str = "hello", ...rest) { } +var y = (function (num = 10, boo = false, ...rest) { })() +var z = (function (num: number, boo = false, ...rest) { })(10) + +//// [emitDefaultParametersFunctionExpressionES6.js] +var lambda1 = function (y = "hello") { +}; +var lambda2 = function (x, y = "hello") { +}; +var lambda3 = function (x, y = "hello", ...rest) { +}; +var lambda4 = function (y = "hello", ...rest) { +}; +var x = function (str = "hello", ...rest) { +}; +var y = (function (num = 10, boo = false, ...rest) { +})(); +var z = (function (num, boo = false, ...rest) { +})(10); diff --git a/tests/baselines/reference/emitDefaultParametersFunctionExpressionES6.types b/tests/baselines/reference/emitDefaultParametersFunctionExpressionES6.types new file mode 100644 index 00000000000..9b8805dfa2b --- /dev/null +++ b/tests/baselines/reference/emitDefaultParametersFunctionExpressionES6.types @@ -0,0 +1,49 @@ +=== tests/cases/conformance/es6/defaultParameters/emitDefaultParametersFunctionExpressionES6.ts === +var lambda1 = (y = "hello") => { } +>lambda1 : (y?: string) => void +>(y = "hello") => { } : (y?: string) => void +>y : string + +var lambda2 = (x: number, y = "hello") => { } +>lambda2 : (x: number, y?: string) => void +>(x: number, y = "hello") => { } : (x: number, y?: string) => void +>x : number +>y : string + +var lambda3 = (x: number, y = "hello", ...rest) => { } +>lambda3 : (x: number, y?: string, ...rest: any[]) => void +>(x: number, y = "hello", ...rest) => { } : (x: number, y?: string, ...rest: any[]) => void +>x : number +>y : string +>rest : any[] + +var lambda4 = (y = "hello", ...rest) => { } +>lambda4 : (y?: string, ...rest: any[]) => void +>(y = "hello", ...rest) => { } : (y?: string, ...rest: any[]) => void +>y : string +>rest : any[] + +var x = function (str = "hello", ...rest) { } +>x : (str?: string, ...rest: any[]) => void +>function (str = "hello", ...rest) { } : (str?: string, ...rest: any[]) => void +>str : string +>rest : any[] + +var y = (function (num = 10, boo = false, ...rest) { })() +>y : void +>(function (num = 10, boo = false, ...rest) { })() : void +>(function (num = 10, boo = false, ...rest) { }) : (num?: number, boo?: boolean, ...rest: any[]) => void +>function (num = 10, boo = false, ...rest) { } : (num?: number, boo?: boolean, ...rest: any[]) => void +>num : number +>boo : boolean +>rest : any[] + +var z = (function (num: number, boo = false, ...rest) { })(10) +>z : void +>(function (num: number, boo = false, ...rest) { })(10) : void +>(function (num: number, boo = false, ...rest) { }) : (num: number, boo?: boolean, ...rest: any[]) => void +>function (num: number, boo = false, ...rest) { } : (num: number, boo?: boolean, ...rest: any[]) => void +>num : number +>boo : boolean +>rest : any[] + diff --git a/tests/baselines/reference/emitDefaultParametersFunctionProperty.js b/tests/baselines/reference/emitDefaultParametersFunctionProperty.js new file mode 100644 index 00000000000..16cac41a4ce --- /dev/null +++ b/tests/baselines/reference/emitDefaultParametersFunctionProperty.js @@ -0,0 +1,32 @@ +//// [emitDefaultParametersFunctionProperty.ts] +var obj2 = { + func1(y = 10, ...rest) { }, + func2(x = "hello") { }, + func3(x: string, z: number, y = "hello") { }, + func4(x: string, z: number, y = "hello", ...rest) { }, +} + + +//// [emitDefaultParametersFunctionProperty.js] +var obj2 = { + func1: function (y) { + if (y === void 0) { y = 10; } + var rest = []; + for (var _i = 1; _i < arguments.length; _i++) { + rest[_i - 1] = arguments[_i]; + } + }, + func2: function (x) { + if (x === void 0) { x = "hello"; } + }, + func3: function (x, z, y) { + if (y === void 0) { y = "hello"; } + }, + func4: function (x, z, y) { + if (y === void 0) { y = "hello"; } + var rest = []; + for (var _i = 3; _i < arguments.length; _i++) { + rest[_i - 3] = arguments[_i]; + } + }, +}; diff --git a/tests/baselines/reference/emitDefaultParametersFunctionProperty.types b/tests/baselines/reference/emitDefaultParametersFunctionProperty.types new file mode 100644 index 00000000000..7c1ea6a5da3 --- /dev/null +++ b/tests/baselines/reference/emitDefaultParametersFunctionProperty.types @@ -0,0 +1,28 @@ +=== tests/cases/conformance/es6/defaultParameters/emitDefaultParametersFunctionProperty.ts === +var obj2 = { +>obj2 : { func1(y?: number, ...rest: any[]): void; func2(x?: string): void; func3(x: string, z: number, y?: string): void; func4(x: string, z: number, y?: string, ...rest: any[]): void; } +>{ func1(y = 10, ...rest) { }, func2(x = "hello") { }, func3(x: string, z: number, y = "hello") { }, func4(x: string, z: number, y = "hello", ...rest) { },} : { func1(y?: number, ...rest: any[]): void; func2(x?: string): void; func3(x: string, z: number, y?: string): void; func4(x: string, z: number, y?: string, ...rest: any[]): void; } + + func1(y = 10, ...rest) { }, +>func1 : (y?: number, ...rest: any[]) => void +>y : number +>rest : any[] + + func2(x = "hello") { }, +>func2 : (x?: string) => void +>x : string + + func3(x: string, z: number, y = "hello") { }, +>func3 : (x: string, z: number, y?: string) => void +>x : string +>z : number +>y : string + + func4(x: string, z: number, y = "hello", ...rest) { }, +>func4 : (x: string, z: number, y?: string, ...rest: any[]) => void +>x : string +>z : number +>y : string +>rest : any[] +} + diff --git a/tests/baselines/reference/emitDefaultParametersFunctionPropertyES6.js b/tests/baselines/reference/emitDefaultParametersFunctionPropertyES6.js new file mode 100644 index 00000000000..fce694a453a --- /dev/null +++ b/tests/baselines/reference/emitDefaultParametersFunctionPropertyES6.js @@ -0,0 +1,19 @@ +//// [emitDefaultParametersFunctionPropertyES6.ts] +var obj2 = { + func1(y = 10, ...rest) { }, + func2(x = "hello") { }, + func3(x: string, z: number, y = "hello") { }, + func4(x: string, z: number, y = "hello", ...rest) { }, +} + +//// [emitDefaultParametersFunctionPropertyES6.js] +var obj2 = { + func1(y = 10, ...rest) { + }, + func2(x = "hello") { + }, + func3(x, z, y = "hello") { + }, + func4(x, z, y = "hello", ...rest) { + }, +}; diff --git a/tests/baselines/reference/emitDefaultParametersFunctionPropertyES6.types b/tests/baselines/reference/emitDefaultParametersFunctionPropertyES6.types new file mode 100644 index 00000000000..ed80158ffd1 --- /dev/null +++ b/tests/baselines/reference/emitDefaultParametersFunctionPropertyES6.types @@ -0,0 +1,27 @@ +=== tests/cases/conformance/es6/defaultParameters/emitDefaultParametersFunctionPropertyES6.ts === +var obj2 = { +>obj2 : { func1(y?: number, ...rest: any[]): void; func2(x?: string): void; func3(x: string, z: number, y?: string): void; func4(x: string, z: number, y?: string, ...rest: any[]): void; } +>{ func1(y = 10, ...rest) { }, func2(x = "hello") { }, func3(x: string, z: number, y = "hello") { }, func4(x: string, z: number, y = "hello", ...rest) { },} : { func1(y?: number, ...rest: any[]): void; func2(x?: string): void; func3(x: string, z: number, y?: string): void; func4(x: string, z: number, y?: string, ...rest: any[]): void; } + + func1(y = 10, ...rest) { }, +>func1 : (y?: number, ...rest: any[]) => void +>y : number +>rest : any[] + + func2(x = "hello") { }, +>func2 : (x?: string) => void +>x : string + + func3(x: string, z: number, y = "hello") { }, +>func3 : (x: string, z: number, y?: string) => void +>x : string +>z : number +>y : string + + func4(x: string, z: number, y = "hello", ...rest) { }, +>func4 : (x: string, z: number, y?: string, ...rest: any[]) => void +>x : string +>z : number +>y : string +>rest : any[] +} diff --git a/tests/baselines/reference/emitDefaultParametersMethod.js b/tests/baselines/reference/emitDefaultParametersMethod.js new file mode 100644 index 00000000000..126c19305b3 --- /dev/null +++ b/tests/baselines/reference/emitDefaultParametersMethod.js @@ -0,0 +1,62 @@ +//// [emitDefaultParametersMethod.ts] +class C { + constructor(t: boolean, z: string, x: number, y = "hello") { } + + public foo(x: string, t = false) { } + public foo1(x: string, t = false, ...rest) { } + public bar(t = false) { } + public boo(t = false, ...rest) { } +} + +class D { + constructor(y = "hello") { } +} + +class E { + constructor(y = "hello", ...rest) { } +} + + +//// [emitDefaultParametersMethod.js] +var C = (function () { + function C(t, z, x, y) { + if (y === void 0) { y = "hello"; } + } + C.prototype.foo = function (x, t) { + if (t === void 0) { t = false; } + }; + C.prototype.foo1 = function (x, t) { + if (t === void 0) { t = false; } + var rest = []; + for (var _i = 2; _i < arguments.length; _i++) { + rest[_i - 2] = arguments[_i]; + } + }; + C.prototype.bar = function (t) { + if (t === void 0) { t = false; } + }; + C.prototype.boo = function (t) { + if (t === void 0) { t = false; } + var rest = []; + for (var _i = 1; _i < arguments.length; _i++) { + rest[_i - 1] = arguments[_i]; + } + }; + return C; +})(); +var D = (function () { + function D(y) { + if (y === void 0) { y = "hello"; } + } + return D; +})(); +var E = (function () { + function E(y) { + if (y === void 0) { y = "hello"; } + var rest = []; + for (var _i = 1; _i < arguments.length; _i++) { + rest[_i - 1] = arguments[_i]; + } + } + return E; +})(); diff --git a/tests/baselines/reference/emitDefaultParametersMethod.types b/tests/baselines/reference/emitDefaultParametersMethod.types new file mode 100644 index 00000000000..5b2f08d4f70 --- /dev/null +++ b/tests/baselines/reference/emitDefaultParametersMethod.types @@ -0,0 +1,46 @@ +=== tests/cases/conformance/es6/defaultParameters/emitDefaultParametersMethod.ts === +class C { +>C : C + + constructor(t: boolean, z: string, x: number, y = "hello") { } +>t : boolean +>z : string +>x : number +>y : string + + public foo(x: string, t = false) { } +>foo : (x: string, t?: boolean) => void +>x : string +>t : boolean + + public foo1(x: string, t = false, ...rest) { } +>foo1 : (x: string, t?: boolean, ...rest: any[]) => void +>x : string +>t : boolean +>rest : any[] + + public bar(t = false) { } +>bar : (t?: boolean) => void +>t : boolean + + public boo(t = false, ...rest) { } +>boo : (t?: boolean, ...rest: any[]) => void +>t : boolean +>rest : any[] +} + +class D { +>D : D + + constructor(y = "hello") { } +>y : string +} + +class E { +>E : E + + constructor(y = "hello", ...rest) { } +>y : string +>rest : any[] +} + diff --git a/tests/baselines/reference/emitDefaultParametersMethodES6.js b/tests/baselines/reference/emitDefaultParametersMethodES6.js new file mode 100644 index 00000000000..bf96e00e375 --- /dev/null +++ b/tests/baselines/reference/emitDefaultParametersMethodES6.js @@ -0,0 +1,42 @@ +//// [emitDefaultParametersMethodES6.ts] +class C { + constructor(t: boolean, z: string, x: number, y = "hello") { } + + public foo(x: string, t = false) { } + public foo1(x: string, t = false, ...rest) { } + public bar(t = false) { } + public boo(t = false, ...rest) { } +} + +class D { + constructor(y = "hello") { } +} + +class E { + constructor(y = "hello", ...rest) { } +} + +//// [emitDefaultParametersMethodES6.js] +var C = (function () { + function C(t, z, x, y = "hello") { + } + C.prototype.foo = function (x, t = false) { + }; + C.prototype.foo1 = function (x, t = false, ...rest) { + }; + C.prototype.bar = function (t = false) { + }; + C.prototype.boo = function (t = false, ...rest) { + }; + return C; +})(); +var D = (function () { + function D(y = "hello") { + } + return D; +})(); +var E = (function () { + function E(y = "hello", ...rest) { + } + return E; +})(); diff --git a/tests/baselines/reference/emitDefaultParametersMethodES6.types b/tests/baselines/reference/emitDefaultParametersMethodES6.types new file mode 100644 index 00000000000..54312714b1d --- /dev/null +++ b/tests/baselines/reference/emitDefaultParametersMethodES6.types @@ -0,0 +1,45 @@ +=== tests/cases/conformance/es6/defaultParameters/emitDefaultParametersMethodES6.ts === +class C { +>C : C + + constructor(t: boolean, z: string, x: number, y = "hello") { } +>t : boolean +>z : string +>x : number +>y : string + + public foo(x: string, t = false) { } +>foo : (x: string, t?: boolean) => void +>x : string +>t : boolean + + public foo1(x: string, t = false, ...rest) { } +>foo1 : (x: string, t?: boolean, ...rest: any[]) => void +>x : string +>t : boolean +>rest : any[] + + public bar(t = false) { } +>bar : (t?: boolean) => void +>t : boolean + + public boo(t = false, ...rest) { } +>boo : (t?: boolean, ...rest: any[]) => void +>t : boolean +>rest : any[] +} + +class D { +>D : D + + constructor(y = "hello") { } +>y : string +} + +class E { +>E : E + + constructor(y = "hello", ...rest) { } +>y : string +>rest : any[] +} diff --git a/tests/baselines/reference/emitRestParametersFunction.js b/tests/baselines/reference/emitRestParametersFunction.js new file mode 100644 index 00000000000..01116f2ac92 --- /dev/null +++ b/tests/baselines/reference/emitRestParametersFunction.js @@ -0,0 +1,17 @@ +//// [emitRestParametersFunction.ts] +function bar(...rest) { } +function foo(x: number, y: string, ...rest) { } + +//// [emitRestParametersFunction.js] +function bar() { + var rest = []; + for (var _i = 0; _i < arguments.length; _i++) { + rest[_i - 0] = arguments[_i]; + } +} +function foo(x, y) { + var rest = []; + for (var _i = 2; _i < arguments.length; _i++) { + rest[_i - 2] = arguments[_i]; + } +} diff --git a/tests/baselines/reference/emitRestParametersFunction.types b/tests/baselines/reference/emitRestParametersFunction.types new file mode 100644 index 00000000000..a65adb57702 --- /dev/null +++ b/tests/baselines/reference/emitRestParametersFunction.types @@ -0,0 +1,11 @@ +=== tests/cases/conformance/es6/restParameters/emitRestParametersFunction.ts === +function bar(...rest) { } +>bar : (...rest: any[]) => void +>rest : any[] + +function foo(x: number, y: string, ...rest) { } +>foo : (x: number, y: string, ...rest: any[]) => void +>x : number +>y : string +>rest : any[] + diff --git a/tests/baselines/reference/emitRestParametersFunctionES6.js b/tests/baselines/reference/emitRestParametersFunctionES6.js new file mode 100644 index 00000000000..242c40f252d --- /dev/null +++ b/tests/baselines/reference/emitRestParametersFunctionES6.js @@ -0,0 +1,9 @@ +//// [emitRestParametersFunctionES6.ts] +function bar(...rest) { } +function foo(x: number, y: string, ...rest) { } + +//// [emitRestParametersFunctionES6.js] +function bar(...rest) { +} +function foo(x, y, ...rest) { +} diff --git a/tests/baselines/reference/emitRestParametersFunctionES6.types b/tests/baselines/reference/emitRestParametersFunctionES6.types new file mode 100644 index 00000000000..5689d64c4df --- /dev/null +++ b/tests/baselines/reference/emitRestParametersFunctionES6.types @@ -0,0 +1,11 @@ +=== tests/cases/conformance/es6/restParameters/emitRestParametersFunctionES6.ts === +function bar(...rest) { } +>bar : (...rest: any[]) => void +>rest : any[] + +function foo(x: number, y: string, ...rest) { } +>foo : (x: number, y: string, ...rest: any[]) => void +>x : number +>y : string +>rest : any[] + diff --git a/tests/baselines/reference/emitRestParametersFunctionExpression.js b/tests/baselines/reference/emitRestParametersFunctionExpression.js new file mode 100644 index 00000000000..da87cc79f2d --- /dev/null +++ b/tests/baselines/reference/emitRestParametersFunctionExpression.js @@ -0,0 +1,32 @@ +//// [emitRestParametersFunctionExpression.ts] +var funcExp = (...rest) => { } +var funcExp1 = (X: number, ...rest) => { } +var funcExp2 = function (...rest) { } +var funcExp3 = (function (...rest) { })() + + +//// [emitRestParametersFunctionExpression.js] +var funcExp = function () { + var rest = []; + for (var _i = 0; _i < arguments.length; _i++) { + rest[_i - 0] = arguments[_i]; + } +}; +var funcExp1 = function (X) { + var rest = []; + for (var _i = 1; _i < arguments.length; _i++) { + rest[_i - 1] = arguments[_i]; + } +}; +var funcExp2 = function () { + var rest = []; + for (var _i = 0; _i < arguments.length; _i++) { + rest[_i - 0] = arguments[_i]; + } +}; +var funcExp3 = (function () { + var rest = []; + for (var _i = 0; _i < arguments.length; _i++) { + rest[_i - 0] = arguments[_i]; + } +})(); diff --git a/tests/baselines/reference/emitRestParametersFunctionExpression.types b/tests/baselines/reference/emitRestParametersFunctionExpression.types new file mode 100644 index 00000000000..9f08b9d9d83 --- /dev/null +++ b/tests/baselines/reference/emitRestParametersFunctionExpression.types @@ -0,0 +1,24 @@ +=== tests/cases/conformance/es6/restParameters/emitRestParametersFunctionExpression.ts === +var funcExp = (...rest) => { } +>funcExp : (...rest: any[]) => void +>(...rest) => { } : (...rest: any[]) => void +>rest : any[] + +var funcExp1 = (X: number, ...rest) => { } +>funcExp1 : (X: number, ...rest: any[]) => void +>(X: number, ...rest) => { } : (X: number, ...rest: any[]) => void +>X : number +>rest : any[] + +var funcExp2 = function (...rest) { } +>funcExp2 : (...rest: any[]) => void +>function (...rest) { } : (...rest: any[]) => void +>rest : any[] + +var funcExp3 = (function (...rest) { })() +>funcExp3 : void +>(function (...rest) { })() : void +>(function (...rest) { }) : (...rest: any[]) => void +>function (...rest) { } : (...rest: any[]) => void +>rest : any[] + diff --git a/tests/baselines/reference/emitRestParametersFunctionExpressionES6.js b/tests/baselines/reference/emitRestParametersFunctionExpressionES6.js new file mode 100644 index 00000000000..6c79e4956ae --- /dev/null +++ b/tests/baselines/reference/emitRestParametersFunctionExpressionES6.js @@ -0,0 +1,15 @@ +//// [emitRestParametersFunctionExpressionES6.ts] +var funcExp = (...rest) => { } +var funcExp1 = (X: number, ...rest) => { } +var funcExp2 = function (...rest) { } +var funcExp3 = (function (...rest) { })() + +//// [emitRestParametersFunctionExpressionES6.js] +var funcExp = function (...rest) { +}; +var funcExp1 = function (X, ...rest) { +}; +var funcExp2 = function (...rest) { +}; +var funcExp3 = (function (...rest) { +})(); diff --git a/tests/baselines/reference/emitRestParametersFunctionExpressionES6.types b/tests/baselines/reference/emitRestParametersFunctionExpressionES6.types new file mode 100644 index 00000000000..224cb37367a --- /dev/null +++ b/tests/baselines/reference/emitRestParametersFunctionExpressionES6.types @@ -0,0 +1,24 @@ +=== tests/cases/conformance/es6/restParameters/emitRestParametersFunctionExpressionES6.ts === +var funcExp = (...rest) => { } +>funcExp : (...rest: any[]) => void +>(...rest) => { } : (...rest: any[]) => void +>rest : any[] + +var funcExp1 = (X: number, ...rest) => { } +>funcExp1 : (X: number, ...rest: any[]) => void +>(X: number, ...rest) => { } : (X: number, ...rest: any[]) => void +>X : number +>rest : any[] + +var funcExp2 = function (...rest) { } +>funcExp2 : (...rest: any[]) => void +>function (...rest) { } : (...rest: any[]) => void +>rest : any[] + +var funcExp3 = (function (...rest) { })() +>funcExp3 : void +>(function (...rest) { })() : void +>(function (...rest) { }) : (...rest: any[]) => void +>function (...rest) { } : (...rest: any[]) => void +>rest : any[] + diff --git a/tests/baselines/reference/emitRestParametersFunctionProperty.js b/tests/baselines/reference/emitRestParametersFunctionProperty.js new file mode 100644 index 00000000000..4fd60a9269d --- /dev/null +++ b/tests/baselines/reference/emitRestParametersFunctionProperty.js @@ -0,0 +1,19 @@ +//// [emitRestParametersFunctionProperty.ts] +var obj: { + func1: (...rest) => void +} + +var obj2 = { + func(...rest) { } +} + +//// [emitRestParametersFunctionProperty.js] +var obj; +var obj2 = { + func: function () { + var rest = []; + for (var _i = 0; _i < arguments.length; _i++) { + rest[_i - 0] = arguments[_i]; + } + } +}; diff --git a/tests/baselines/reference/emitRestParametersFunctionProperty.types b/tests/baselines/reference/emitRestParametersFunctionProperty.types new file mode 100644 index 00000000000..8242e742ee0 --- /dev/null +++ b/tests/baselines/reference/emitRestParametersFunctionProperty.types @@ -0,0 +1,17 @@ +=== tests/cases/conformance/es6/restParameters/emitRestParametersFunctionProperty.ts === +var obj: { +>obj : { func1: (...rest: any[]) => void; } + + func1: (...rest) => void +>func1 : (...rest: any[]) => void +>rest : any[] +} + +var obj2 = { +>obj2 : { func(...rest: any[]): void; } +>{ func(...rest) { }} : { func(...rest: any[]): void; } + + func(...rest) { } +>func : (...rest: any[]) => void +>rest : any[] +} diff --git a/tests/baselines/reference/emitRestParametersFunctionPropertyES6.js b/tests/baselines/reference/emitRestParametersFunctionPropertyES6.js new file mode 100644 index 00000000000..87aa489ecf3 --- /dev/null +++ b/tests/baselines/reference/emitRestParametersFunctionPropertyES6.js @@ -0,0 +1,15 @@ +//// [emitRestParametersFunctionPropertyES6.ts] +var obj: { + func1: (...rest) => void +} + +var obj2 = { + func(...rest) { } +} + +//// [emitRestParametersFunctionPropertyES6.js] +var obj; +var obj2 = { + func(...rest) { + } +}; diff --git a/tests/baselines/reference/emitRestParametersFunctionPropertyES6.types b/tests/baselines/reference/emitRestParametersFunctionPropertyES6.types new file mode 100644 index 00000000000..07a008cd4c0 --- /dev/null +++ b/tests/baselines/reference/emitRestParametersFunctionPropertyES6.types @@ -0,0 +1,17 @@ +=== tests/cases/conformance/es6/restParameters/emitRestParametersFunctionPropertyES6.ts === +var obj: { +>obj : { func1: (...rest: any[]) => void; } + + func1: (...rest) => void +>func1 : (...rest: any[]) => void +>rest : any[] +} + +var obj2 = { +>obj2 : { func(...rest: any[]): void; } +>{ func(...rest) { }} : { func(...rest: any[]): void; } + + func(...rest) { } +>func : (...rest: any[]) => void +>rest : any[] +} diff --git a/tests/baselines/reference/emitRestParametersMethod.js b/tests/baselines/reference/emitRestParametersMethod.js new file mode 100644 index 00000000000..5ceb6d768f8 --- /dev/null +++ b/tests/baselines/reference/emitRestParametersMethod.js @@ -0,0 +1,58 @@ +//// [emitRestParametersMethod.ts] +class C { + constructor(name: string, ...rest) { } + + public bar(...rest) { } + public foo(x: number, ...rest) { } +} + +class D { + constructor(...rest) { } + + public bar(...rest) { } + public foo(x: number, ...rest) { } +} + +//// [emitRestParametersMethod.js] +var C = (function () { + function C(name) { + var rest = []; + for (var _i = 1; _i < arguments.length; _i++) { + rest[_i - 1] = arguments[_i]; + } + } + C.prototype.bar = function () { + var rest = []; + for (var _i = 0; _i < arguments.length; _i++) { + rest[_i - 0] = arguments[_i]; + } + }; + C.prototype.foo = function (x) { + var rest = []; + for (var _i = 1; _i < arguments.length; _i++) { + rest[_i - 1] = arguments[_i]; + } + }; + return C; +})(); +var D = (function () { + function D() { + var rest = []; + for (var _i = 0; _i < arguments.length; _i++) { + rest[_i - 0] = arguments[_i]; + } + } + D.prototype.bar = function () { + var rest = []; + for (var _i = 0; _i < arguments.length; _i++) { + rest[_i - 0] = arguments[_i]; + } + }; + D.prototype.foo = function (x) { + var rest = []; + for (var _i = 1; _i < arguments.length; _i++) { + rest[_i - 1] = arguments[_i]; + } + }; + return D; +})(); diff --git a/tests/baselines/reference/emitRestParametersMethod.types b/tests/baselines/reference/emitRestParametersMethod.types new file mode 100644 index 00000000000..c94561ca737 --- /dev/null +++ b/tests/baselines/reference/emitRestParametersMethod.types @@ -0,0 +1,33 @@ +=== tests/cases/conformance/es6/restParameters/emitRestParametersMethod.ts === +class C { +>C : C + + constructor(name: string, ...rest) { } +>name : string +>rest : any[] + + public bar(...rest) { } +>bar : (...rest: any[]) => void +>rest : any[] + + public foo(x: number, ...rest) { } +>foo : (x: number, ...rest: any[]) => void +>x : number +>rest : any[] +} + +class D { +>D : D + + constructor(...rest) { } +>rest : any[] + + public bar(...rest) { } +>bar : (...rest: any[]) => void +>rest : any[] + + public foo(x: number, ...rest) { } +>foo : (x: number, ...rest: any[]) => void +>x : number +>rest : any[] +} diff --git a/tests/baselines/reference/emitRestParametersMethodES6.js b/tests/baselines/reference/emitRestParametersMethodES6.js new file mode 100644 index 00000000000..d0a0e2a120c --- /dev/null +++ b/tests/baselines/reference/emitRestParametersMethodES6.js @@ -0,0 +1,35 @@ +//// [emitRestParametersMethodES6.ts] +class C { + constructor(name: string, ...rest) { } + + public bar(...rest) { } + public foo(x: number, ...rest) { } +} + +class D { + constructor(...rest) { } + + public bar(...rest) { } + public foo(x: number, ...rest) { } +} + + +//// [emitRestParametersMethodES6.js] +var C = (function () { + function C(name, ...rest) { + } + C.prototype.bar = function (...rest) { + }; + C.prototype.foo = function (x, ...rest) { + }; + return C; +})(); +var D = (function () { + function D(...rest) { + } + D.prototype.bar = function (...rest) { + }; + D.prototype.foo = function (x, ...rest) { + }; + return D; +})(); diff --git a/tests/baselines/reference/emitRestParametersMethodES6.types b/tests/baselines/reference/emitRestParametersMethodES6.types new file mode 100644 index 00000000000..4555a5c666d --- /dev/null +++ b/tests/baselines/reference/emitRestParametersMethodES6.types @@ -0,0 +1,34 @@ +=== tests/cases/conformance/es6/restParameters/emitRestParametersMethodES6.ts === +class C { +>C : C + + constructor(name: string, ...rest) { } +>name : string +>rest : any[] + + public bar(...rest) { } +>bar : (...rest: any[]) => void +>rest : any[] + + public foo(x: number, ...rest) { } +>foo : (x: number, ...rest: any[]) => void +>x : number +>rest : any[] +} + +class D { +>D : D + + constructor(...rest) { } +>rest : any[] + + public bar(...rest) { } +>bar : (...rest: any[]) => void +>rest : any[] + + public foo(x: number, ...rest) { } +>foo : (x: number, ...rest: any[]) => void +>x : number +>rest : any[] +} + diff --git a/tests/baselines/reference/inheritedOverloadedSpecializedSignatures.js b/tests/baselines/reference/inheritedOverloadedSpecializedSignatures.js index 792c9232fa2..da16ad0d0e5 100644 --- a/tests/baselines/reference/inheritedOverloadedSpecializedSignatures.js +++ b/tests/baselines/reference/inheritedOverloadedSpecializedSignatures.js @@ -28,22 +28,43 @@ interface B { (x: 'B2'): string[]; } -var b: B; -// non of these lines should error -var x1: string[] = b('B2'); -var x2: number = b('B1'); -var x3: boolean = b('A2'); -var x4: string = b('A1'); -var x5: void = b('A0'); +interface C1 extends B { + (x: 'C1'): number[]; +} + +interface C2 extends B { + (x: 'C2'): boolean[]; +} + +interface C extends C1, C2 { + (x: 'C'): string; +} + +var c: C; +// none of these lines should error +var x1: string[] = c('B2'); +var x2: number = c('B1'); +var x3: boolean = c('A2'); +var x4: string = c('A1'); +var x5: void = c('A0'); +var x6: number[] = c('C1'); +var x7: boolean[] = c('C2'); +var x8: string = c('C'); +var x9: void = c('generic'); + //// [inheritedOverloadedSpecializedSignatures.js] var b; // Should not error b('foo').charAt(0); -var b; -// non of these lines should error -var x1 = b('B2'); -var x2 = b('B1'); -var x3 = b('A2'); -var x4 = b('A1'); -var x5 = b('A0'); +var c; +// none of these lines should error +var x1 = c('B2'); +var x2 = c('B1'); +var x3 = c('A2'); +var x4 = c('A1'); +var x5 = c('A0'); +var x6 = c('C1'); +var x7 = c('C2'); +var x8 = c('C'); +var x9 = c('generic'); diff --git a/tests/baselines/reference/inheritedOverloadedSpecializedSignatures.types b/tests/baselines/reference/inheritedOverloadedSpecializedSignatures.types index 0284fa4bc43..dcbab74b681 100644 --- a/tests/baselines/reference/inheritedOverloadedSpecializedSignatures.types +++ b/tests/baselines/reference/inheritedOverloadedSpecializedSignatures.types @@ -58,33 +58,78 @@ interface B { >x : 'B2' } -var b: B; ->b : B +interface C1 extends B { +>C1 : C1 >B : B -// non of these lines should error -var x1: string[] = b('B2'); + (x: 'C1'): number[]; +>x : 'C1' +} + +interface C2 extends B { +>C2 : C2 +>B : B + + (x: 'C2'): boolean[]; +>x : 'C2' +} + +interface C extends C1, C2 { +>C : C +>C1 : C1 +>C2 : C2 + + (x: 'C'): string; +>x : 'C' +} + +var c: C; +>c : C +>C : C + +// none of these lines should error +var x1: string[] = c('B2'); >x1 : string[] ->b('B2') : string[] ->b : B +>c('B2') : string[] +>c : C -var x2: number = b('B1'); +var x2: number = c('B1'); >x2 : number ->b('B1') : number ->b : B +>c('B1') : number +>c : C -var x3: boolean = b('A2'); +var x3: boolean = c('A2'); >x3 : boolean ->b('A2') : boolean ->b : B +>c('A2') : boolean +>c : C -var x4: string = b('A1'); +var x4: string = c('A1'); >x4 : string ->b('A1') : string ->b : B +>c('A1') : string +>c : C -var x5: void = b('A0'); +var x5: void = c('A0'); >x5 : void ->b('A0') : void ->b : B +>c('A0') : void +>c : C + +var x6: number[] = c('C1'); +>x6 : number[] +>c('C1') : number[] +>c : C + +var x7: boolean[] = c('C2'); +>x7 : boolean[] +>c('C2') : boolean[] +>c : C + +var x8: string = c('C'); +>x8 : string +>c('C') : string +>c : C + +var x9: void = c('generic'); +>x9 : void +>c('generic') : void +>c : C diff --git a/tests/baselines/reference/logicalOrExpressionIsNotContextuallyTyped.types b/tests/baselines/reference/logicalOrExpressionIsNotContextuallyTyped.types index f450307758d..72fd6281ba9 100644 --- a/tests/baselines/reference/logicalOrExpressionIsNotContextuallyTyped.types +++ b/tests/baselines/reference/logicalOrExpressionIsNotContextuallyTyped.types @@ -11,14 +11,14 @@ var a: (a: string) => string; // bug 786110 var r = a || ((a) => a.toLowerCase()); ->r : (a: any) => any ->a || ((a) => a.toLowerCase()) : (a: any) => any +>r : (a: string) => string +>a || ((a) => a.toLowerCase()) : (a: string) => string >a : (a: string) => string ->((a) => a.toLowerCase()) : (a: any) => any ->(a) => a.toLowerCase() : (a: any) => any ->a : any ->a.toLowerCase() : any ->a.toLowerCase : any ->a : any ->toLowerCase : any +>((a) => a.toLowerCase()) : (a: string) => string +>(a) => a.toLowerCase() : (a: string) => string +>a : string +>a.toLowerCase() : string +>a.toLowerCase : () => string +>a : string +>toLowerCase : () => string diff --git a/tests/baselines/reference/optionalBindingParameters1.errors.txt b/tests/baselines/reference/optionalBindingParameters1.errors.txt new file mode 100644 index 00000000000..a2961fb9651 --- /dev/null +++ b/tests/baselines/reference/optionalBindingParameters1.errors.txt @@ -0,0 +1,17 @@ +tests/cases/conformance/es6/destructuring/optionalBindingParameters1.ts(2,14): error TS2463: A binding pattern parameter cannot be optional in an implementation signature. +tests/cases/conformance/es6/destructuring/optionalBindingParameters1.ts(8,5): error TS2345: Argument of type '[boolean, number, string]' is not assignable to parameter of type '[string, number, boolean]'. + + +==== tests/cases/conformance/es6/destructuring/optionalBindingParameters1.ts (2 errors) ==== + + function foo([x,y,z]?: [string, number, boolean]) { + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +!!! error TS2463: A binding pattern parameter cannot be optional in an implementation signature. + + } + + foo(["", 0, false]); + + foo([false, 0, ""]); + ~~~~~~~~~~~~~~ +!!! error TS2345: Argument of type '[boolean, number, string]' is not assignable to parameter of type '[string, number, boolean]'. \ No newline at end of file diff --git a/tests/baselines/reference/optionalBindingParameters1.js b/tests/baselines/reference/optionalBindingParameters1.js new file mode 100644 index 00000000000..536cb1e567a --- /dev/null +++ b/tests/baselines/reference/optionalBindingParameters1.js @@ -0,0 +1,16 @@ +//// [optionalBindingParameters1.ts] + +function foo([x,y,z]?: [string, number, boolean]) { + +} + +foo(["", 0, false]); + +foo([false, 0, ""]); + +//// [optionalBindingParameters1.js] +function foo(_a) { + var x = _a[0], y = _a[1], z = _a[2]; +} +foo(["", 0, false]); +foo([false, 0, ""]); diff --git a/tests/baselines/reference/optionalBindingParameters2.errors.txt b/tests/baselines/reference/optionalBindingParameters2.errors.txt new file mode 100644 index 00000000000..e67687722d0 --- /dev/null +++ b/tests/baselines/reference/optionalBindingParameters2.errors.txt @@ -0,0 +1,21 @@ +tests/cases/conformance/es6/destructuring/optionalBindingParameters2.ts(2,14): error TS2463: A binding pattern parameter cannot be optional in an implementation signature. +tests/cases/conformance/es6/destructuring/optionalBindingParameters2.ts(8,5): error TS2345: Argument of type '{ x: boolean; y: number; z: string; }' is not assignable to parameter of type '{ x: string; y: number; z: boolean; }'. + Types of property 'x' are incompatible. + Type 'boolean' is not assignable to type 'string'. + + +==== tests/cases/conformance/es6/destructuring/optionalBindingParameters2.ts (2 errors) ==== + + function foo({ x, y, z }?: { x: string; y: number; z: boolean }) { + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +!!! error TS2463: A binding pattern parameter cannot be optional in an implementation signature. + + } + + foo({ x: "", y: 0, z: false }); + + foo({ x: false, y: 0, z: "" }); + ~~~~~~~~~~~~~~~~~~~~~~~~~ +!!! error TS2345: Argument of type '{ x: boolean; y: number; z: string; }' is not assignable to parameter of type '{ x: string; y: number; z: boolean; }'. +!!! error TS2345: Types of property 'x' are incompatible. +!!! error TS2345: Type 'boolean' is not assignable to type 'string'. \ No newline at end of file diff --git a/tests/baselines/reference/optionalBindingParameters2.js b/tests/baselines/reference/optionalBindingParameters2.js new file mode 100644 index 00000000000..04e1138561a --- /dev/null +++ b/tests/baselines/reference/optionalBindingParameters2.js @@ -0,0 +1,16 @@ +//// [optionalBindingParameters2.ts] + +function foo({ x, y, z }?: { x: string; y: number; z: boolean }) { + +} + +foo({ x: "", y: 0, z: false }); + +foo({ x: false, y: 0, z: "" }); + +//// [optionalBindingParameters2.js] +function foo(_a) { + var x = _a.x, y = _a.y, z = _a.z; +} +foo({ x: "", y: 0, z: false }); +foo({ x: false, y: 0, z: "" }); diff --git a/tests/baselines/reference/optionalBindingParametersInOverloads1.errors.txt b/tests/baselines/reference/optionalBindingParametersInOverloads1.errors.txt new file mode 100644 index 00000000000..5999ec514b0 --- /dev/null +++ b/tests/baselines/reference/optionalBindingParametersInOverloads1.errors.txt @@ -0,0 +1,15 @@ +tests/cases/conformance/es6/destructuring/optionalBindingParametersInOverloads1.ts(9,5): error TS2345: Argument of type '[boolean, number, string]' is not assignable to parameter of type '[string, number, boolean]'. + + +==== tests/cases/conformance/es6/destructuring/optionalBindingParametersInOverloads1.ts (1 errors) ==== + + function foo([x, y, z] ?: [string, number, boolean]); + function foo(...rest: any[]) { + + } + + foo(["", 0, false]); + + foo([false, 0, ""]); + ~~~~~~~~~~~~~~ +!!! error TS2345: Argument of type '[boolean, number, string]' is not assignable to parameter of type '[string, number, boolean]'. \ No newline at end of file diff --git a/tests/baselines/reference/optionalBindingParametersInOverloads1.js b/tests/baselines/reference/optionalBindingParametersInOverloads1.js new file mode 100644 index 00000000000..3658efa72c6 --- /dev/null +++ b/tests/baselines/reference/optionalBindingParametersInOverloads1.js @@ -0,0 +1,20 @@ +//// [optionalBindingParametersInOverloads1.ts] + +function foo([x, y, z] ?: [string, number, boolean]); +function foo(...rest: any[]) { + +} + +foo(["", 0, false]); + +foo([false, 0, ""]); + +//// [optionalBindingParametersInOverloads1.js] +function foo() { + var rest = []; + for (var _i = 0; _i < arguments.length; _i++) { + rest[_i - 0] = arguments[_i]; + } +} +foo(["", 0, false]); +foo([false, 0, ""]); diff --git a/tests/baselines/reference/optionalBindingParametersInOverloads2.errors.txt b/tests/baselines/reference/optionalBindingParametersInOverloads2.errors.txt new file mode 100644 index 00000000000..765fd5e3de6 --- /dev/null +++ b/tests/baselines/reference/optionalBindingParametersInOverloads2.errors.txt @@ -0,0 +1,19 @@ +tests/cases/conformance/es6/destructuring/optionalBindingParametersInOverloads2.ts(9,5): error TS2345: Argument of type '{ x: boolean; y: number; z: string; }' is not assignable to parameter of type '{ x: string; y: number; z: boolean; }'. + Types of property 'x' are incompatible. + Type 'boolean' is not assignable to type 'string'. + + +==== tests/cases/conformance/es6/destructuring/optionalBindingParametersInOverloads2.ts (1 errors) ==== + + function foo({ x, y, z }?: { x: string; y: number; z: boolean }); + function foo(...rest: any[]) { + + } + + foo({ x: "", y: 0, z: false }); + + foo({ x: false, y: 0, z: "" }); + ~~~~~~~~~~~~~~~~~~~~~~~~~ +!!! error TS2345: Argument of type '{ x: boolean; y: number; z: string; }' is not assignable to parameter of type '{ x: string; y: number; z: boolean; }'. +!!! error TS2345: Types of property 'x' are incompatible. +!!! error TS2345: Type 'boolean' is not assignable to type 'string'. \ No newline at end of file diff --git a/tests/baselines/reference/optionalBindingParametersInOverloads2.js b/tests/baselines/reference/optionalBindingParametersInOverloads2.js new file mode 100644 index 00000000000..1ddfdae4f07 --- /dev/null +++ b/tests/baselines/reference/optionalBindingParametersInOverloads2.js @@ -0,0 +1,20 @@ +//// [optionalBindingParametersInOverloads2.ts] + +function foo({ x, y, z }?: { x: string; y: number; z: boolean }); +function foo(...rest: any[]) { + +} + +foo({ x: "", y: 0, z: false }); + +foo({ x: false, y: 0, z: "" }); + +//// [optionalBindingParametersInOverloads2.js] +function foo() { + var rest = []; + for (var _i = 0; _i < arguments.length; _i++) { + rest[_i - 0] = arguments[_i]; + } +} +foo({ x: "", y: 0, z: false }); +foo({ x: false, y: 0, z: "" }); diff --git a/tests/baselines/reference/parenthesizedContexualTyping1.js b/tests/baselines/reference/parenthesizedContexualTyping1.js new file mode 100644 index 00000000000..2f1e9ff62fc --- /dev/null +++ b/tests/baselines/reference/parenthesizedContexualTyping1.js @@ -0,0 +1,52 @@ +//// [parenthesizedContexualTyping1.ts] + +function fun(g: (x: T) => T, x: T): T; +function fun(g: (x: T) => T, h: (y: T) => T, x: T): T; +function fun(g: (x: T) => T, x: T): T { + return g(x); +} + +var a = fun(x => x, 10); +var b = fun((x => x), 10); +var c = fun(((x => x)), 10); +var d = fun((((x => x))), 10); + +var e = fun(x => x, x => x, 10); +var f = fun((x => x), (x => x), 10); +var g = fun(((x => x)), ((x => x)), 10); +var h = fun((((x => x))), ((x => x)), 10); + +// Ternaries in parens +var i = fun((Math.random() < 0.5 ? x => x : x => undefined), 10); +var j = fun((Math.random() < 0.5 ? (x => x) : (x => undefined)), 10); +var k = fun((Math.random() < 0.5 ? (x => x) : (x => undefined)), x => x, 10); +var l = fun(((Math.random() < 0.5 ? ((x => x)) : ((x => undefined)))), ((x => x)), 10); + +var lambda1: (x: number) => number = x => x; +var lambda2: (x: number) => number = (x => x); + +type ObjType = { x: (p: number) => string; y: (p: string) => number }; +var obj1: ObjType = { x: x => (x, undefined), y: y => (y, undefined) }; +var obj2: ObjType = ({ x: x => (x, undefined), y: y => (y, undefined) }); + +//// [parenthesizedContexualTyping1.js] +function fun(g, x) { + return g(x); +} +var a = fun(function (x) { return x; }, 10); +var b = fun((function (x) { return x; }), 10); +var c = fun(((function (x) { return x; })), 10); +var d = fun((((function (x) { return x; }))), 10); +var e = fun(function (x) { return x; }, function (x) { return x; }, 10); +var f = fun((function (x) { return x; }), (function (x) { return x; }), 10); +var g = fun(((function (x) { return x; })), ((function (x) { return x; })), 10); +var h = fun((((function (x) { return x; }))), ((function (x) { return x; })), 10); +// Ternaries in parens +var i = fun((Math.random() < 0.5 ? function (x) { return x; } : function (x) { return undefined; }), 10); +var j = fun((Math.random() < 0.5 ? (function (x) { return x; }) : (function (x) { return undefined; })), 10); +var k = fun((Math.random() < 0.5 ? (function (x) { return x; }) : (function (x) { return undefined; })), function (x) { return x; }, 10); +var l = fun(((Math.random() < 0.5 ? ((function (x) { return x; })) : ((function (x) { return undefined; })))), ((function (x) { return x; })), 10); +var lambda1 = function (x) { return x; }; +var lambda2 = (function (x) { return x; }); +var obj1 = { x: function (x) { return (x, undefined); }, y: function (y) { return (y, undefined); } }; +var obj2 = ({ x: function (x) { return (x, undefined); }, y: function (y) { return (y, undefined); } }); diff --git a/tests/baselines/reference/parenthesizedContexualTyping1.types b/tests/baselines/reference/parenthesizedContexualTyping1.types new file mode 100644 index 00000000000..60020fd8eb2 --- /dev/null +++ b/tests/baselines/reference/parenthesizedContexualTyping1.types @@ -0,0 +1,289 @@ +=== tests/cases/conformance/expressions/contextualTyping/parenthesizedContexualTyping1.ts === + +function fun(g: (x: T) => T, x: T): T; +>fun : { (g: (x: T) => T, x: T): T; (g: (x: T) => T, h: (y: T) => T, x: T): T; } +>T : T +>g : (x: T) => T +>x : T +>T : T +>T : T +>x : T +>T : T +>T : T + +function fun(g: (x: T) => T, h: (y: T) => T, x: T): T; +>fun : { (g: (x: T) => T, x: T): T; (g: (x: T) => T, h: (y: T) => T, x: T): T; } +>T : T +>g : (x: T) => T +>x : T +>T : T +>T : T +>h : (y: T) => T +>y : T +>T : T +>T : T +>x : T +>T : T +>T : T + +function fun(g: (x: T) => T, x: T): T { +>fun : { (g: (x: T) => T, x: T): T; (g: (x: T) => T, h: (y: T) => T, x: T): T; } +>T : T +>g : (x: T) => T +>x : T +>T : T +>T : T +>x : T +>T : T +>T : T + + return g(x); +>g(x) : T +>g : (x: T) => T +>x : T +} + +var a = fun(x => x, 10); +>a : number +>fun(x => x, 10) : number +>fun : { (g: (x: T) => T, x: T): T; (g: (x: T) => T, h: (y: T) => T, x: T): T; } +>x => x : (x: number) => number +>x : number +>x : number + +var b = fun((x => x), 10); +>b : number +>fun((x => x), 10) : number +>fun : { (g: (x: T) => T, x: T): T; (g: (x: T) => T, h: (y: T) => T, x: T): T; } +>(x => x) : (x: number) => number +>x => x : (x: number) => number +>x : number +>x : number + +var c = fun(((x => x)), 10); +>c : number +>fun(((x => x)), 10) : number +>fun : { (g: (x: T) => T, x: T): T; (g: (x: T) => T, h: (y: T) => T, x: T): T; } +>((x => x)) : (x: number) => number +>(x => x) : (x: number) => number +>x => x : (x: number) => number +>x : number +>x : number + +var d = fun((((x => x))), 10); +>d : number +>fun((((x => x))), 10) : number +>fun : { (g: (x: T) => T, x: T): T; (g: (x: T) => T, h: (y: T) => T, x: T): T; } +>(((x => x))) : (x: number) => number +>((x => x)) : (x: number) => number +>(x => x) : (x: number) => number +>x => x : (x: number) => number +>x : number +>x : number + +var e = fun(x => x, x => x, 10); +>e : number +>fun(x => x, x => x, 10) : number +>fun : { (g: (x: T) => T, x: T): T; (g: (x: T) => T, h: (y: T) => T, x: T): T; } +>x => x : (x: number) => number +>x : number +>x : number +>x => x : (x: number) => number +>x : number +>x : number + +var f = fun((x => x), (x => x), 10); +>f : number +>fun((x => x), (x => x), 10) : number +>fun : { (g: (x: T) => T, x: T): T; (g: (x: T) => T, h: (y: T) => T, x: T): T; } +>(x => x) : (x: number) => number +>x => x : (x: number) => number +>x : number +>x : number +>(x => x) : (x: number) => number +>x => x : (x: number) => number +>x : number +>x : number + +var g = fun(((x => x)), ((x => x)), 10); +>g : number +>fun(((x => x)), ((x => x)), 10) : number +>fun : { (g: (x: T) => T, x: T): T; (g: (x: T) => T, h: (y: T) => T, x: T): T; } +>((x => x)) : (x: number) => number +>(x => x) : (x: number) => number +>x => x : (x: number) => number +>x : number +>x : number +>((x => x)) : (x: number) => number +>(x => x) : (x: number) => number +>x => x : (x: number) => number +>x : number +>x : number + +var h = fun((((x => x))), ((x => x)), 10); +>h : number +>fun((((x => x))), ((x => x)), 10) : number +>fun : { (g: (x: T) => T, x: T): T; (g: (x: T) => T, h: (y: T) => T, x: T): T; } +>(((x => x))) : (x: number) => number +>((x => x)) : (x: number) => number +>(x => x) : (x: number) => number +>x => x : (x: number) => number +>x : number +>x : number +>((x => x)) : (x: number) => number +>(x => x) : (x: number) => number +>x => x : (x: number) => number +>x : number +>x : number + +// Ternaries in parens +var i = fun((Math.random() < 0.5 ? x => x : x => undefined), 10); +>i : any +>fun((Math.random() < 0.5 ? x => x : x => undefined), 10) : any +>fun : { (g: (x: T) => T, x: T): T; (g: (x: T) => T, h: (y: T) => T, x: T): T; } +>(Math.random() < 0.5 ? x => x : x => undefined) : (x: number) => any +>Math.random() < 0.5 ? x => x : x => undefined : (x: number) => any +>Math.random() < 0.5 : boolean +>Math.random() : number +>Math.random : () => number +>Math : Math +>random : () => number +>x => x : (x: number) => number +>x : number +>x : number +>x => undefined : (x: number) => any +>x : number +>undefined : undefined + +var j = fun((Math.random() < 0.5 ? (x => x) : (x => undefined)), 10); +>j : any +>fun((Math.random() < 0.5 ? (x => x) : (x => undefined)), 10) : any +>fun : { (g: (x: T) => T, x: T): T; (g: (x: T) => T, h: (y: T) => T, x: T): T; } +>(Math.random() < 0.5 ? (x => x) : (x => undefined)) : (x: number) => any +>Math.random() < 0.5 ? (x => x) : (x => undefined) : (x: number) => any +>Math.random() < 0.5 : boolean +>Math.random() : number +>Math.random : () => number +>Math : Math +>random : () => number +>(x => x) : (x: number) => number +>x => x : (x: number) => number +>x : number +>x : number +>(x => undefined) : (x: number) => any +>x => undefined : (x: number) => any +>x : number +>undefined : undefined + +var k = fun((Math.random() < 0.5 ? (x => x) : (x => undefined)), x => x, 10); +>k : any +>fun((Math.random() < 0.5 ? (x => x) : (x => undefined)), x => x, 10) : any +>fun : { (g: (x: T) => T, x: T): T; (g: (x: T) => T, h: (y: T) => T, x: T): T; } +>(Math.random() < 0.5 ? (x => x) : (x => undefined)) : (x: number) => any +>Math.random() < 0.5 ? (x => x) : (x => undefined) : (x: number) => any +>Math.random() < 0.5 : boolean +>Math.random() : number +>Math.random : () => number +>Math : Math +>random : () => number +>(x => x) : (x: number) => number +>x => x : (x: number) => number +>x : number +>x : number +>(x => undefined) : (x: number) => any +>x => undefined : (x: number) => any +>x : number +>undefined : undefined +>x => x : (x: any) => any +>x : any +>x : any + +var l = fun(((Math.random() < 0.5 ? ((x => x)) : ((x => undefined)))), ((x => x)), 10); +>l : any +>fun(((Math.random() < 0.5 ? ((x => x)) : ((x => undefined)))), ((x => x)), 10) : any +>fun : { (g: (x: T) => T, x: T): T; (g: (x: T) => T, h: (y: T) => T, x: T): T; } +>((Math.random() < 0.5 ? ((x => x)) : ((x => undefined)))) : (x: number) => any +>(Math.random() < 0.5 ? ((x => x)) : ((x => undefined))) : (x: number) => any +>Math.random() < 0.5 ? ((x => x)) : ((x => undefined)) : (x: number) => any +>Math.random() < 0.5 : boolean +>Math.random() : number +>Math.random : () => number +>Math : Math +>random : () => number +>((x => x)) : (x: number) => number +>(x => x) : (x: number) => number +>x => x : (x: number) => number +>x : number +>x : number +>((x => undefined)) : (x: number) => any +>(x => undefined) : (x: number) => any +>x => undefined : (x: number) => any +>x : number +>undefined : undefined +>((x => x)) : (x: number) => number +>(x => x) : (x: number) => number +>x => x : (x: number) => number +>x : number +>x : number + +var lambda1: (x: number) => number = x => x; +>lambda1 : (x: number) => number +>x : number +>x => x : (x: number) => number +>x : number +>x : number + +var lambda2: (x: number) => number = (x => x); +>lambda2 : (x: number) => number +>x : number +>(x => x) : (x: number) => number +>x => x : (x: number) => number +>x : number +>x : number + +type ObjType = { x: (p: number) => string; y: (p: string) => number }; +>ObjType : { x: (p: number) => string; y: (p: string) => number; } +>x : (p: number) => string +>p : number +>y : (p: string) => number +>p : string + +var obj1: ObjType = { x: x => (x, undefined), y: y => (y, undefined) }; +>obj1 : { x: (p: number) => string; y: (p: string) => number; } +>ObjType : { x: (p: number) => string; y: (p: string) => number; } +>{ x: x => (x, undefined), y: y => (y, undefined) } : { x: (x: number) => any; y: (y: string) => any; } +>x : (x: number) => any +>x => (x, undefined) : (x: number) => any +>x : number +>(x, undefined) : undefined +>x, undefined : undefined +>x : number +>undefined : undefined +>y : (y: string) => any +>y => (y, undefined) : (y: string) => any +>y : string +>(y, undefined) : undefined +>y, undefined : undefined +>y : string +>undefined : undefined + +var obj2: ObjType = ({ x: x => (x, undefined), y: y => (y, undefined) }); +>obj2 : { x: (p: number) => string; y: (p: string) => number; } +>ObjType : { x: (p: number) => string; y: (p: string) => number; } +>({ x: x => (x, undefined), y: y => (y, undefined) }) : { x: (x: number) => any; y: (y: string) => any; } +>{ x: x => (x, undefined), y: y => (y, undefined) } : { x: (x: number) => any; y: (y: string) => any; } +>x : (x: number) => any +>x => (x, undefined) : (x: number) => any +>x : number +>(x, undefined) : undefined +>x, undefined : undefined +>x : number +>undefined : undefined +>y : (y: string) => any +>y => (y, undefined) : (y: string) => any +>y : string +>(y, undefined) : undefined +>y, undefined : undefined +>y : string +>undefined : undefined + diff --git a/tests/baselines/reference/parenthesizedContexualTyping2.js b/tests/baselines/reference/parenthesizedContexualTyping2.js new file mode 100644 index 00000000000..d5e4e0ebe8f --- /dev/null +++ b/tests/baselines/reference/parenthesizedContexualTyping2.js @@ -0,0 +1,128 @@ +//// [parenthesizedContexualTyping2.ts] +// These tests ensure that in cases where it may *appear* that a value has a type, +// they actually are properly being contextually typed. The way we test this is +// that we invoke contextually typed arguments with type arguments. +// Since 'any' cannot be invoked with type arguments, we should get errors +// back if contextual typing is not taking effect. + +type FuncType = (x: (p: T) => T) => typeof x; + +function fun(f: FuncType, x: T): T; +function fun(f: FuncType, g: FuncType, x: T): T; +function fun(...rest: any[]): T { + return undefined; +} + +var a = fun(x => { x(undefined); return x; }, 10); +var b = fun((x => { x(undefined); return x; }), 10); +var c = fun(((x => { x(undefined); return x; })), 10); +var d = fun((((x => { x(undefined); return x; }))), 10); + +var e = fun(x => { x(undefined); return x; }, x => { x(undefined); return x; }, 10); +var f = fun((x => { x(undefined); return x; }),(x => { x(undefined); return x; }), 10); +var g = fun(((x => { x(undefined); return x; })),((x => { x(undefined); return x; })), 10); +var h = fun((((x => { x(undefined); return x; }))),((x => { x(undefined); return x; })), 10); + +// Ternaries in parens +var i = fun((Math.random() < 0.5 ? x => { x(undefined); return x; } : x => undefined), 10); +var j = fun((Math.random() < 0.5 ? (x => { x(undefined); return x; }) : (x => undefined)), 10); +var k = fun((Math.random() < 0.5 ? (x => { x(undefined); return x; }) : (x => undefined)), x => { x(undefined); return x; }, 10); +var l = fun(((Math.random() < 0.5 ? ((x => { x(undefined); return x; })) : ((x => undefined)))),((x => { x(undefined); return x; })), 10); + +var lambda1: FuncType = x => { x(undefined); return x; }; +var lambda2: FuncType = (x => { x(undefined); return x; }); + +type ObjType = { x: (p: number) => string; y: (p: string) => number }; +var obj1: ObjType = { x: x => (x, undefined), y: y => (y, undefined) }; +var obj2: ObjType = ({ x: x => (x, undefined), y: y => (y, undefined) }); + +//// [parenthesizedContexualTyping2.js] +// These tests ensure that in cases where it may *appear* that a value has a type, +// they actually are properly being contextually typed. The way we test this is +// that we invoke contextually typed arguments with type arguments. +// Since 'any' cannot be invoked with type arguments, we should get errors +// back if contextual typing is not taking effect. +function fun() { + var rest = []; + for (var _i = 0; _i < arguments.length; _i++) { + rest[_i - 0] = arguments[_i]; + } + return undefined; +} +var a = fun(function (x) { + x(undefined); + return x; +}, 10); +var b = fun((function (x) { + x(undefined); + return x; +}), 10); +var c = fun(((function (x) { + x(undefined); + return x; +})), 10); +var d = fun((((function (x) { + x(undefined); + return x; +}))), 10); +var e = fun(function (x) { + x(undefined); + return x; +}, function (x) { + x(undefined); + return x; +}, 10); +var f = fun((function (x) { + x(undefined); + return x; +}), (function (x) { + x(undefined); + return x; +}), 10); +var g = fun(((function (x) { + x(undefined); + return x; +})), ((function (x) { + x(undefined); + return x; +})), 10); +var h = fun((((function (x) { + x(undefined); + return x; +}))), ((function (x) { + x(undefined); + return x; +})), 10); +// Ternaries in parens +var i = fun((Math.random() < 0.5 ? function (x) { + x(undefined); + return x; +} : function (x) { return undefined; }), 10); +var j = fun((Math.random() < 0.5 ? (function (x) { + x(undefined); + return x; +}) : (function (x) { return undefined; })), 10); +var k = fun((Math.random() < 0.5 ? (function (x) { + x(undefined); + return x; +}) : (function (x) { return undefined; })), function (x) { + x(undefined); + return x; +}, 10); +var l = fun(((Math.random() < 0.5 ? ((function (x) { + x(undefined); + return x; +})) : ((function (x) { return undefined; })))), ((function (x) { + x(undefined); + return x; +})), 10); +var lambda1 = function (x) { + x(undefined); + return x; +}; +var lambda2 = (function (x) { + x(undefined); + return x; +}); +var obj1 = { x: function (x) { return (x, undefined); }, y: function (y) { return (y, undefined); } }; +var obj2 = ({ x: function (x) { return (x, undefined); }, y: function (y) { return (y, undefined); } }); diff --git a/tests/baselines/reference/parenthesizedContexualTyping2.types b/tests/baselines/reference/parenthesizedContexualTyping2.types new file mode 100644 index 00000000000..6824cc0f6e9 --- /dev/null +++ b/tests/baselines/reference/parenthesizedContexualTyping2.types @@ -0,0 +1,350 @@ +=== tests/cases/conformance/expressions/contextualTyping/parenthesizedContexualTyping2.ts === +// These tests ensure that in cases where it may *appear* that a value has a type, +// they actually are properly being contextually typed. The way we test this is +// that we invoke contextually typed arguments with type arguments. +// Since 'any' cannot be invoked with type arguments, we should get errors +// back if contextual typing is not taking effect. + +type FuncType = (x: (p: T) => T) => typeof x; +>FuncType : (x: (p: T) => T) => (p: T) => T +>x : (p: T) => T +>T : T +>p : T +>T : T +>T : T +>x : (p: T) => T + +function fun(f: FuncType, x: T): T; +>fun : { (f: (x: (p: T) => T) => (p: T) => T, x: T): T; (f: (x: (p: T) => T) => (p: T) => T, g: (x: (p: T) => T) => (p: T) => T, x: T): T; } +>T : T +>f : (x: (p: T) => T) => (p: T) => T +>FuncType : (x: (p: T) => T) => (p: T) => T +>x : T +>T : T +>T : T + +function fun(f: FuncType, g: FuncType, x: T): T; +>fun : { (f: (x: (p: T) => T) => (p: T) => T, x: T): T; (f: (x: (p: T) => T) => (p: T) => T, g: (x: (p: T) => T) => (p: T) => T, x: T): T; } +>T : T +>f : (x: (p: T) => T) => (p: T) => T +>FuncType : (x: (p: T) => T) => (p: T) => T +>g : (x: (p: T) => T) => (p: T) => T +>FuncType : (x: (p: T) => T) => (p: T) => T +>x : T +>T : T +>T : T + +function fun(...rest: any[]): T { +>fun : { (f: (x: (p: T) => T) => (p: T) => T, x: T): T; (f: (x: (p: T) => T) => (p: T) => T, g: (x: (p: T) => T) => (p: T) => T, x: T): T; } +>T : T +>rest : any[] +>T : T + + return undefined; +>undefined : undefined +} + +var a = fun(x => { x(undefined); return x; }, 10); +>a : number +>fun(x => { x(undefined); return x; }, 10) : number +>fun : { (f: (x: (p: T) => T) => (p: T) => T, x: T): T; (f: (x: (p: T) => T) => (p: T) => T, g: (x: (p: T) => T) => (p: T) => T, x: T): T; } +>x => { x(undefined); return x; } : (x: (p: T) => T) => (p: T) => T +>x : (p: T) => T +>x(undefined) : number +>x : (p: T) => T +>undefined : undefined +>x : (p: T) => T + +var b = fun((x => { x(undefined); return x; }), 10); +>b : number +>fun((x => { x(undefined); return x; }), 10) : number +>fun : { (f: (x: (p: T) => T) => (p: T) => T, x: T): T; (f: (x: (p: T) => T) => (p: T) => T, g: (x: (p: T) => T) => (p: T) => T, x: T): T; } +>(x => { x(undefined); return x; }) : (x: (p: T) => T) => (p: T) => T +>x => { x(undefined); return x; } : (x: (p: T) => T) => (p: T) => T +>x : (p: T) => T +>x(undefined) : number +>x : (p: T) => T +>undefined : undefined +>x : (p: T) => T + +var c = fun(((x => { x(undefined); return x; })), 10); +>c : number +>fun(((x => { x(undefined); return x; })), 10) : number +>fun : { (f: (x: (p: T) => T) => (p: T) => T, x: T): T; (f: (x: (p: T) => T) => (p: T) => T, g: (x: (p: T) => T) => (p: T) => T, x: T): T; } +>((x => { x(undefined); return x; })) : (x: (p: T) => T) => (p: T) => T +>(x => { x(undefined); return x; }) : (x: (p: T) => T) => (p: T) => T +>x => { x(undefined); return x; } : (x: (p: T) => T) => (p: T) => T +>x : (p: T) => T +>x(undefined) : number +>x : (p: T) => T +>undefined : undefined +>x : (p: T) => T + +var d = fun((((x => { x(undefined); return x; }))), 10); +>d : number +>fun((((x => { x(undefined); return x; }))), 10) : number +>fun : { (f: (x: (p: T) => T) => (p: T) => T, x: T): T; (f: (x: (p: T) => T) => (p: T) => T, g: (x: (p: T) => T) => (p: T) => T, x: T): T; } +>(((x => { x(undefined); return x; }))) : (x: (p: T) => T) => (p: T) => T +>((x => { x(undefined); return x; })) : (x: (p: T) => T) => (p: T) => T +>(x => { x(undefined); return x; }) : (x: (p: T) => T) => (p: T) => T +>x => { x(undefined); return x; } : (x: (p: T) => T) => (p: T) => T +>x : (p: T) => T +>x(undefined) : number +>x : (p: T) => T +>undefined : undefined +>x : (p: T) => T + +var e = fun(x => { x(undefined); return x; }, x => { x(undefined); return x; }, 10); +>e : number +>fun(x => { x(undefined); return x; }, x => { x(undefined); return x; }, 10) : number +>fun : { (f: (x: (p: T) => T) => (p: T) => T, x: T): T; (f: (x: (p: T) => T) => (p: T) => T, g: (x: (p: T) => T) => (p: T) => T, x: T): T; } +>x => { x(undefined); return x; } : (x: (p: T) => T) => (p: T) => T +>x : (p: T) => T +>x(undefined) : number +>x : (p: T) => T +>undefined : undefined +>x : (p: T) => T +>x => { x(undefined); return x; } : (x: (p: T) => T) => (p: T) => T +>x : (p: T) => T +>x(undefined) : number +>x : (p: T) => T +>undefined : undefined +>x : (p: T) => T + +var f = fun((x => { x(undefined); return x; }),(x => { x(undefined); return x; }), 10); +>f : number +>fun((x => { x(undefined); return x; }),(x => { x(undefined); return x; }), 10) : number +>fun : { (f: (x: (p: T) => T) => (p: T) => T, x: T): T; (f: (x: (p: T) => T) => (p: T) => T, g: (x: (p: T) => T) => (p: T) => T, x: T): T; } +>(x => { x(undefined); return x; }) : (x: (p: T) => T) => (p: T) => T +>x => { x(undefined); return x; } : (x: (p: T) => T) => (p: T) => T +>x : (p: T) => T +>x(undefined) : number +>x : (p: T) => T +>undefined : undefined +>x : (p: T) => T +>(x => { x(undefined); return x; }) : (x: (p: T) => T) => (p: T) => T +>x => { x(undefined); return x; } : (x: (p: T) => T) => (p: T) => T +>x : (p: T) => T +>x(undefined) : number +>x : (p: T) => T +>undefined : undefined +>x : (p: T) => T + +var g = fun(((x => { x(undefined); return x; })),((x => { x(undefined); return x; })), 10); +>g : number +>fun(((x => { x(undefined); return x; })),((x => { x(undefined); return x; })), 10) : number +>fun : { (f: (x: (p: T) => T) => (p: T) => T, x: T): T; (f: (x: (p: T) => T) => (p: T) => T, g: (x: (p: T) => T) => (p: T) => T, x: T): T; } +>((x => { x(undefined); return x; })) : (x: (p: T) => T) => (p: T) => T +>(x => { x(undefined); return x; }) : (x: (p: T) => T) => (p: T) => T +>x => { x(undefined); return x; } : (x: (p: T) => T) => (p: T) => T +>x : (p: T) => T +>x(undefined) : number +>x : (p: T) => T +>undefined : undefined +>x : (p: T) => T +>((x => { x(undefined); return x; })) : (x: (p: T) => T) => (p: T) => T +>(x => { x(undefined); return x; }) : (x: (p: T) => T) => (p: T) => T +>x => { x(undefined); return x; } : (x: (p: T) => T) => (p: T) => T +>x : (p: T) => T +>x(undefined) : number +>x : (p: T) => T +>undefined : undefined +>x : (p: T) => T + +var h = fun((((x => { x(undefined); return x; }))),((x => { x(undefined); return x; })), 10); +>h : number +>fun((((x => { x(undefined); return x; }))),((x => { x(undefined); return x; })), 10) : number +>fun : { (f: (x: (p: T) => T) => (p: T) => T, x: T): T; (f: (x: (p: T) => T) => (p: T) => T, g: (x: (p: T) => T) => (p: T) => T, x: T): T; } +>(((x => { x(undefined); return x; }))) : (x: (p: T) => T) => (p: T) => T +>((x => { x(undefined); return x; })) : (x: (p: T) => T) => (p: T) => T +>(x => { x(undefined); return x; }) : (x: (p: T) => T) => (p: T) => T +>x => { x(undefined); return x; } : (x: (p: T) => T) => (p: T) => T +>x : (p: T) => T +>x(undefined) : number +>x : (p: T) => T +>undefined : undefined +>x : (p: T) => T +>((x => { x(undefined); return x; })) : (x: (p: T) => T) => (p: T) => T +>(x => { x(undefined); return x; }) : (x: (p: T) => T) => (p: T) => T +>x => { x(undefined); return x; } : (x: (p: T) => T) => (p: T) => T +>x : (p: T) => T +>x(undefined) : number +>x : (p: T) => T +>undefined : undefined +>x : (p: T) => T + +// Ternaries in parens +var i = fun((Math.random() < 0.5 ? x => { x(undefined); return x; } : x => undefined), 10); +>i : number +>fun((Math.random() < 0.5 ? x => { x(undefined); return x; } : x => undefined), 10) : number +>fun : { (f: (x: (p: T) => T) => (p: T) => T, x: T): T; (f: (x: (p: T) => T) => (p: T) => T, g: (x: (p: T) => T) => (p: T) => T, x: T): T; } +>(Math.random() < 0.5 ? x => { x(undefined); return x; } : x => undefined) : (x: (p: T) => T) => any +>Math.random() < 0.5 ? x => { x(undefined); return x; } : x => undefined : (x: (p: T) => T) => any +>Math.random() < 0.5 : boolean +>Math.random() : number +>Math.random : () => number +>Math : Math +>random : () => number +>x => { x(undefined); return x; } : (x: (p: T) => T) => (p: T) => T +>x : (p: T) => T +>x(undefined) : number +>x : (p: T) => T +>undefined : undefined +>x : (p: T) => T +>x => undefined : (x: (p: T) => T) => any +>x : (p: T) => T +>undefined : undefined + +var j = fun((Math.random() < 0.5 ? (x => { x(undefined); return x; }) : (x => undefined)), 10); +>j : number +>fun((Math.random() < 0.5 ? (x => { x(undefined); return x; }) : (x => undefined)), 10) : number +>fun : { (f: (x: (p: T) => T) => (p: T) => T, x: T): T; (f: (x: (p: T) => T) => (p: T) => T, g: (x: (p: T) => T) => (p: T) => T, x: T): T; } +>(Math.random() < 0.5 ? (x => { x(undefined); return x; }) : (x => undefined)) : (x: (p: T) => T) => any +>Math.random() < 0.5 ? (x => { x(undefined); return x; }) : (x => undefined) : (x: (p: T) => T) => any +>Math.random() < 0.5 : boolean +>Math.random() : number +>Math.random : () => number +>Math : Math +>random : () => number +>(x => { x(undefined); return x; }) : (x: (p: T) => T) => (p: T) => T +>x => { x(undefined); return x; } : (x: (p: T) => T) => (p: T) => T +>x : (p: T) => T +>x(undefined) : number +>x : (p: T) => T +>undefined : undefined +>x : (p: T) => T +>(x => undefined) : (x: (p: T) => T) => any +>x => undefined : (x: (p: T) => T) => any +>x : (p: T) => T +>undefined : undefined + +var k = fun((Math.random() < 0.5 ? (x => { x(undefined); return x; }) : (x => undefined)), x => { x(undefined); return x; }, 10); +>k : number +>fun((Math.random() < 0.5 ? (x => { x(undefined); return x; }) : (x => undefined)), x => { x(undefined); return x; }, 10) : number +>fun : { (f: (x: (p: T) => T) => (p: T) => T, x: T): T; (f: (x: (p: T) => T) => (p: T) => T, g: (x: (p: T) => T) => (p: T) => T, x: T): T; } +>(Math.random() < 0.5 ? (x => { x(undefined); return x; }) : (x => undefined)) : (x: (p: T) => T) => any +>Math.random() < 0.5 ? (x => { x(undefined); return x; }) : (x => undefined) : (x: (p: T) => T) => any +>Math.random() < 0.5 : boolean +>Math.random() : number +>Math.random : () => number +>Math : Math +>random : () => number +>(x => { x(undefined); return x; }) : (x: (p: T) => T) => (p: T) => T +>x => { x(undefined); return x; } : (x: (p: T) => T) => (p: T) => T +>x : (p: T) => T +>x(undefined) : number +>x : (p: T) => T +>undefined : undefined +>x : (p: T) => T +>(x => undefined) : (x: (p: T) => T) => any +>x => undefined : (x: (p: T) => T) => any +>x : (p: T) => T +>undefined : undefined +>x => { x(undefined); return x; } : (x: (p: T) => T) => (p: T) => T +>x : (p: T) => T +>x(undefined) : number +>x : (p: T) => T +>undefined : undefined +>x : (p: T) => T + +var l = fun(((Math.random() < 0.5 ? ((x => { x(undefined); return x; })) : ((x => undefined)))),((x => { x(undefined); return x; })), 10); +>l : number +>fun(((Math.random() < 0.5 ? ((x => { x(undefined); return x; })) : ((x => undefined)))),((x => { x(undefined); return x; })), 10) : number +>fun : { (f: (x: (p: T) => T) => (p: T) => T, x: T): T; (f: (x: (p: T) => T) => (p: T) => T, g: (x: (p: T) => T) => (p: T) => T, x: T): T; } +>((Math.random() < 0.5 ? ((x => { x(undefined); return x; })) : ((x => undefined)))) : (x: (p: T) => T) => any +>(Math.random() < 0.5 ? ((x => { x(undefined); return x; })) : ((x => undefined))) : (x: (p: T) => T) => any +>Math.random() < 0.5 ? ((x => { x(undefined); return x; })) : ((x => undefined)) : (x: (p: T) => T) => any +>Math.random() < 0.5 : boolean +>Math.random() : number +>Math.random : () => number +>Math : Math +>random : () => number +>((x => { x(undefined); return x; })) : (x: (p: T) => T) => (p: T) => T +>(x => { x(undefined); return x; }) : (x: (p: T) => T) => (p: T) => T +>x => { x(undefined); return x; } : (x: (p: T) => T) => (p: T) => T +>x : (p: T) => T +>x(undefined) : number +>x : (p: T) => T +>undefined : undefined +>x : (p: T) => T +>((x => undefined)) : (x: (p: T) => T) => any +>(x => undefined) : (x: (p: T) => T) => any +>x => undefined : (x: (p: T) => T) => any +>x : (p: T) => T +>undefined : undefined +>((x => { x(undefined); return x; })) : (x: (p: T) => T) => (p: T) => T +>(x => { x(undefined); return x; }) : (x: (p: T) => T) => (p: T) => T +>x => { x(undefined); return x; } : (x: (p: T) => T) => (p: T) => T +>x : (p: T) => T +>x(undefined) : number +>x : (p: T) => T +>undefined : undefined +>x : (p: T) => T + +var lambda1: FuncType = x => { x(undefined); return x; }; +>lambda1 : (x: (p: T) => T) => (p: T) => T +>FuncType : (x: (p: T) => T) => (p: T) => T +>x => { x(undefined); return x; } : (x: (p: T) => T) => (p: T) => T +>x : (p: T) => T +>x(undefined) : number +>x : (p: T) => T +>undefined : undefined +>x : (p: T) => T + +var lambda2: FuncType = (x => { x(undefined); return x; }); +>lambda2 : (x: (p: T) => T) => (p: T) => T +>FuncType : (x: (p: T) => T) => (p: T) => T +>(x => { x(undefined); return x; }) : (x: (p: T) => T) => (p: T) => T +>x => { x(undefined); return x; } : (x: (p: T) => T) => (p: T) => T +>x : (p: T) => T +>x(undefined) : number +>x : (p: T) => T +>undefined : undefined +>x : (p: T) => T + +type ObjType = { x: (p: number) => string; y: (p: string) => number }; +>ObjType : { x: (p: number) => string; y: (p: string) => number; } +>x : (p: number) => string +>p : number +>y : (p: string) => number +>p : string + +var obj1: ObjType = { x: x => (x, undefined), y: y => (y, undefined) }; +>obj1 : { x: (p: number) => string; y: (p: string) => number; } +>ObjType : { x: (p: number) => string; y: (p: string) => number; } +>{ x: x => (x, undefined), y: y => (y, undefined) } : { x: (x: number) => any; y: (y: string) => any; } +>x : (x: number) => any +>x => (x, undefined) : (x: number) => any +>x : number +>(x, undefined) : undefined +>x, undefined : undefined +>x : number +>undefined : undefined +>y : (y: string) => any +>y => (y, undefined) : (y: string) => any +>y : string +>(y, undefined) : undefined +>y, undefined : undefined +>y : string +>undefined : undefined + +var obj2: ObjType = ({ x: x => (x, undefined), y: y => (y, undefined) }); +>obj2 : { x: (p: number) => string; y: (p: string) => number; } +>ObjType : { x: (p: number) => string; y: (p: string) => number; } +>({ x: x => (x, undefined), y: y => (y, undefined) }) : { x: (x: number) => any; y: (y: string) => any; } +>{ x: x => (x, undefined), y: y => (y, undefined) } : { x: (x: number) => any; y: (y: string) => any; } +>x : (x: number) => any +>x => (x, undefined) : (x: number) => any +>x : number +>(x, undefined) : undefined +>x, undefined : undefined +>x : number +>undefined : undefined +>y : (y: string) => any +>y => (y, undefined) : (y: string) => any +>y : string +>(y, undefined) : undefined +>y, undefined : undefined +>y : string +>undefined : undefined + diff --git a/tests/baselines/reference/parenthesizedContexualTyping3.js b/tests/baselines/reference/parenthesizedContexualTyping3.js new file mode 100644 index 00000000000..69784d14ce4 --- /dev/null +++ b/tests/baselines/reference/parenthesizedContexualTyping3.js @@ -0,0 +1,35 @@ +//// [parenthesizedContexualTyping3.ts] + +// Contextual typing for parenthesized substitution expressions in tagged templates. + +/** + * tempFun - Can't have fun for too long. + */ +function tempFun(tempStrs: TemplateStringsArray, g: (x: T) => T, x: T): T; +function tempFun(tempStrs: TemplateStringsArray, g: (x: T) => T, h: (y: T) => T, x: T): T; +function tempFun(tempStrs: TemplateStringsArray, g: (x: T) => T, x: T): T { + return g(x); +} + +var a = tempFun `${ x => x } ${ 10 }` +var b = tempFun `${ (x => x) } ${ 10 }` +var c = tempFun `${ ((x => x)) } ${ 10 }` +var d = tempFun `${ x => x } ${ x => x } ${ 10 }` +var e = tempFun `${ x => x } ${ (x => x) } ${ 10 }` +var f = tempFun `${ x => x } ${ ((x => x)) } ${ 10 }` +var g = tempFun `${ (x => x) } ${ (((x => x))) } ${ 10 }` +var h = tempFun `${ (x => x) } ${ (((x => x))) } ${ undefined }` + +//// [parenthesizedContexualTyping3.js] +// Contextual typing for parenthesized substitution expressions in tagged templates. +function tempFun(tempStrs, g, x) { + return g(x); +} +var a = tempFun `${function (x) { return x; }} ${10}`; +var b = tempFun `${(function (x) { return x; })} ${10}`; +var c = tempFun `${((function (x) { return x; }))} ${10}`; +var d = tempFun `${function (x) { return x; }} ${function (x) { return x; }} ${10}`; +var e = tempFun `${function (x) { return x; }} ${(function (x) { return x; })} ${10}`; +var f = tempFun `${function (x) { return x; }} ${((function (x) { return x; }))} ${10}`; +var g = tempFun `${(function (x) { return x; })} ${(((function (x) { return x; })))} ${10}`; +var h = tempFun `${(function (x) { return x; })} ${(((function (x) { return x; })))} ${undefined}`; diff --git a/tests/baselines/reference/parenthesizedContexualTyping3.types b/tests/baselines/reference/parenthesizedContexualTyping3.types new file mode 100644 index 00000000000..26c0207e523 --- /dev/null +++ b/tests/baselines/reference/parenthesizedContexualTyping3.types @@ -0,0 +1,142 @@ +=== tests/cases/conformance/expressions/contextualTyping/parenthesizedContexualTyping3.ts === + +// Contextual typing for parenthesized substitution expressions in tagged templates. + +/** + * tempFun - Can't have fun for too long. + */ +function tempFun(tempStrs: TemplateStringsArray, g: (x: T) => T, x: T): T; +>tempFun : { (tempStrs: TemplateStringsArray, g: (x: T) => T, x: T): T; (tempStrs: TemplateStringsArray, g: (x: T) => T, h: (y: T) => T, x: T): T; } +>T : T +>tempStrs : TemplateStringsArray +>TemplateStringsArray : TemplateStringsArray +>g : (x: T) => T +>x : T +>T : T +>T : T +>x : T +>T : T +>T : T + +function tempFun(tempStrs: TemplateStringsArray, g: (x: T) => T, h: (y: T) => T, x: T): T; +>tempFun : { (tempStrs: TemplateStringsArray, g: (x: T) => T, x: T): T; (tempStrs: TemplateStringsArray, g: (x: T) => T, h: (y: T) => T, x: T): T; } +>T : T +>tempStrs : TemplateStringsArray +>TemplateStringsArray : TemplateStringsArray +>g : (x: T) => T +>x : T +>T : T +>T : T +>h : (y: T) => T +>y : T +>T : T +>T : T +>x : T +>T : T +>T : T + +function tempFun(tempStrs: TemplateStringsArray, g: (x: T) => T, x: T): T { +>tempFun : { (tempStrs: TemplateStringsArray, g: (x: T) => T, x: T): T; (tempStrs: TemplateStringsArray, g: (x: T) => T, h: (y: T) => T, x: T): T; } +>T : T +>tempStrs : TemplateStringsArray +>TemplateStringsArray : TemplateStringsArray +>g : (x: T) => T +>x : T +>T : T +>T : T +>x : T +>T : T +>T : T + + return g(x); +>g(x) : T +>g : (x: T) => T +>x : T +} + +var a = tempFun `${ x => x } ${ 10 }` +>a : number +>tempFun : { (tempStrs: TemplateStringsArray, g: (x: T) => T, x: T): T; (tempStrs: TemplateStringsArray, g: (x: T) => T, h: (y: T) => T, x: T): T; } +>x => x : (x: number) => number +>x : number +>x : number + +var b = tempFun `${ (x => x) } ${ 10 }` +>b : number +>tempFun : { (tempStrs: TemplateStringsArray, g: (x: T) => T, x: T): T; (tempStrs: TemplateStringsArray, g: (x: T) => T, h: (y: T) => T, x: T): T; } +>(x => x) : (x: number) => number +>x => x : (x: number) => number +>x : number +>x : number + +var c = tempFun `${ ((x => x)) } ${ 10 }` +>c : number +>tempFun : { (tempStrs: TemplateStringsArray, g: (x: T) => T, x: T): T; (tempStrs: TemplateStringsArray, g: (x: T) => T, h: (y: T) => T, x: T): T; } +>((x => x)) : (x: number) => number +>(x => x) : (x: number) => number +>x => x : (x: number) => number +>x : number +>x : number + +var d = tempFun `${ x => x } ${ x => x } ${ 10 }` +>d : number +>tempFun : { (tempStrs: TemplateStringsArray, g: (x: T) => T, x: T): T; (tempStrs: TemplateStringsArray, g: (x: T) => T, h: (y: T) => T, x: T): T; } +>x => x : (x: number) => number +>x : number +>x : number +>x => x : (x: number) => number +>x : number +>x : number + +var e = tempFun `${ x => x } ${ (x => x) } ${ 10 }` +>e : number +>tempFun : { (tempStrs: TemplateStringsArray, g: (x: T) => T, x: T): T; (tempStrs: TemplateStringsArray, g: (x: T) => T, h: (y: T) => T, x: T): T; } +>x => x : (x: number) => number +>x : number +>x : number +>(x => x) : (x: number) => number +>x => x : (x: number) => number +>x : number +>x : number + +var f = tempFun `${ x => x } ${ ((x => x)) } ${ 10 }` +>f : number +>tempFun : { (tempStrs: TemplateStringsArray, g: (x: T) => T, x: T): T; (tempStrs: TemplateStringsArray, g: (x: T) => T, h: (y: T) => T, x: T): T; } +>x => x : (x: number) => number +>x : number +>x : number +>((x => x)) : (x: number) => number +>(x => x) : (x: number) => number +>x => x : (x: number) => number +>x : number +>x : number + +var g = tempFun `${ (x => x) } ${ (((x => x))) } ${ 10 }` +>g : number +>tempFun : { (tempStrs: TemplateStringsArray, g: (x: T) => T, x: T): T; (tempStrs: TemplateStringsArray, g: (x: T) => T, h: (y: T) => T, x: T): T; } +>(x => x) : (x: number) => number +>x => x : (x: number) => number +>x : number +>x : number +>(((x => x))) : (x: number) => number +>((x => x)) : (x: number) => number +>(x => x) : (x: number) => number +>x => x : (x: number) => number +>x : number +>x : number + +var h = tempFun `${ (x => x) } ${ (((x => x))) } ${ undefined }` +>h : any +>tempFun : { (tempStrs: TemplateStringsArray, g: (x: T) => T, x: T): T; (tempStrs: TemplateStringsArray, g: (x: T) => T, h: (y: T) => T, x: T): T; } +>(x => x) : (x: any) => any +>x => x : (x: any) => any +>x : any +>x : any +>(((x => x))) : (x: any) => any +>((x => x)) : (x: any) => any +>(x => x) : (x: any) => any +>x => x : (x: any) => any +>x : any +>x : any +>undefined : undefined + diff --git a/tests/baselines/reference/taggedTemplateContextualTyping1.js b/tests/baselines/reference/taggedTemplateContextualTyping1.js index d631a718bf3..c1ae5c384e4 100644 --- a/tests/baselines/reference/taggedTemplateContextualTyping1.js +++ b/tests/baselines/reference/taggedTemplateContextualTyping1.js @@ -12,6 +12,7 @@ function tempTag1(...rest: any[]): T { // Otherwise, the arrow functions' parameters will be typed as 'any', // and it is an error to invoke an any-typed value with type arguments, // so this test will error. +tempTag1 `${ x => { x(undefined); return x; } }${ 10 }`; tempTag1 `${ x => { x(undefined); return x; } }${ y => { y(undefined); return y; } }${ 10 }`; tempTag1 `${ x => { x(undefined); return x; } }${ (y: (p: T) => T) => { y(undefined); return y } }${ undefined }`; tempTag1 `${ (x: (p: T) => T) => { x(undefined); return x; } }${ y => { y(undefined); return y; } }${ undefined }`; @@ -25,6 +26,10 @@ function tempTag1(...rest) { // Otherwise, the arrow functions' parameters will be typed as 'any', // and it is an error to invoke an any-typed value with type arguments, // so this test will error. +tempTag1 `${function (x) { + x(undefined); + return x; +}}${10}`; tempTag1 `${function (x) { x(undefined); return x; diff --git a/tests/baselines/reference/taggedTemplateContextualTyping1.types b/tests/baselines/reference/taggedTemplateContextualTyping1.types index a87d5eaa7a4..a6432d34f81 100644 --- a/tests/baselines/reference/taggedTemplateContextualTyping1.types +++ b/tests/baselines/reference/taggedTemplateContextualTyping1.types @@ -47,6 +47,15 @@ function tempTag1(...rest: any[]): T { // Otherwise, the arrow functions' parameters will be typed as 'any', // and it is an error to invoke an any-typed value with type arguments, // so this test will error. +tempTag1 `${ x => { x(undefined); return x; } }${ 10 }`; +>tempTag1 : { (templateStrs: TemplateStringsArray, f: (x: (p: T) => T) => (p: T) => T, x: T): T; (templateStrs: TemplateStringsArray, f: (x: (p: T) => T) => (p: T) => T, h: (x: (p: T) => T) => (p: T) => T, x: T): T; } +>x => { x(undefined); return x; } : (x: (p: T) => T) => (p: T) => T +>x : (p: T) => T +>x(undefined) : number +>x : (p: T) => T +>undefined : undefined +>x : (p: T) => T + tempTag1 `${ x => { x(undefined); return x; } }${ y => { y(undefined); return y; } }${ 10 }`; >tempTag1 : { (templateStrs: TemplateStringsArray, f: (x: (p: T) => T) => (p: T) => T, x: T): T; (templateStrs: TemplateStringsArray, f: (x: (p: T) => T) => (p: T) => T, h: (x: (p: T) => T) => (p: T) => T, x: T): T; } >x => { x(undefined); return x; } : (x: (p: T) => T) => (p: T) => T diff --git a/tests/baselines/reference/templateStringBinaryOperations.js b/tests/baselines/reference/templateStringBinaryOperations.js index d155ba9eedd..691dad41f77 100644 --- a/tests/baselines/reference/templateStringBinaryOperations.js +++ b/tests/baselines/reference/templateStringBinaryOperations.js @@ -55,49 +55,49 @@ var l4 = 1 + `2${ 3 & 4 }5` + 6; //// [templateStringBinaryOperations.js] var a = 1 + ("" + 3); var b = 1 + ("2" + 3); -var c = 1 + ("" + 3 + "4"); +var c = 1 + (3 + "4"); var d = 1 + ("2" + 3 + "4"); var e = ("" + 3) + 5; var f = ("2" + 3) + 5; -var g = ("" + 3 + "4") + 5; +var g = (3 + "4") + 5; var h = ("2" + 3 + "4") + 5; var i = 1 + ("" + 3) + 5; var j = 1 + ("2" + 3) + 5; -var k = 1 + ("" + 3 + "4") + 5; +var k = 1 + (3 + "4") + 5; var l = 1 + ("2" + 3 + "4") + 5; var a2 = 1 + ("" + (3 - 4)); var b2 = 1 + ("2" + (3 - 4)); -var c2 = 1 + ("" + (3 - 4) + "5"); +var c2 = 1 + ((3 - 4) + "5"); var d2 = 1 + ("2" + (3 - 4) + "5"); var e2 = ("" + (3 - 4)) + 6; var f2 = ("2" + (3 - 4)) + 6; -var g2 = ("" + (3 - 4) + "5") + 6; +var g2 = ((3 - 4) + "5") + 6; var h2 = ("2" + (3 - 4) + "5") + 6; var i2 = 1 + ("" + (3 - 4)) + 6; var j2 = 1 + ("2" + (3 - 4)) + 6; -var k2 = 1 + ("" + (3 - 4) + "5") + 6; +var k2 = 1 + ((3 - 4) + "5") + 6; var l2 = 1 + ("2" + (3 - 4) + "5") + 6; var a3 = 1 + ("" + 3 * 4); var b3 = 1 + ("2" + 3 * 4); -var c3 = 1 + ("" + 3 * 4 + "5"); +var c3 = 1 + (3 * 4 + "5"); var d3 = 1 + ("2" + 3 * 4 + "5"); var e3 = ("" + 3 * 4) + 6; var f3 = ("2" + 3 * 4) + 6; -var g3 = ("" + 3 * 4 + "5") + 6; +var g3 = (3 * 4 + "5") + 6; var h3 = ("2" + 3 * 4 + "5") + 6; var i3 = 1 + ("" + 3 * 4) + 6; var j3 = 1 + ("2" + 3 * 4) + 6; -var k3 = 1 + ("" + 3 * 4 + "5") + 6; +var k3 = 1 + (3 * 4 + "5") + 6; var l3 = 1 + ("2" + 3 * 4 + "5") + 6; var a4 = 1 + ("" + (3 & 4)); var b4 = 1 + ("2" + (3 & 4)); -var c4 = 1 + ("" + (3 & 4) + "5"); +var c4 = 1 + ((3 & 4) + "5"); var d4 = 1 + ("2" + (3 & 4) + "5"); var e4 = ("" + (3 & 4)) + 6; var f4 = ("2" + (3 & 4)) + 6; -var g4 = ("" + (3 & 4) + "5") + 6; +var g4 = ((3 & 4) + "5") + 6; var h4 = ("2" + (3 & 4) + "5") + 6; var i4 = 1 + ("" + (3 & 4)) + 6; var j4 = 1 + ("2" + (3 & 4)) + 6; -var k4 = 1 + ("" + (3 & 4) + "5") + 6; +var k4 = 1 + ((3 & 4) + "5") + 6; var l4 = 1 + ("2" + (3 & 4) + "5") + 6; diff --git a/tests/baselines/reference/templateStringBinaryOperationsInvalid.js b/tests/baselines/reference/templateStringBinaryOperationsInvalid.js index 1edf1d3a563..f8c0344f44b 100644 --- a/tests/baselines/reference/templateStringBinaryOperationsInvalid.js +++ b/tests/baselines/reference/templateStringBinaryOperationsInvalid.js @@ -111,97 +111,97 @@ var hc = `2${ 3 & 4 }5` & 6; //// [templateStringBinaryOperationsInvalid.js] var a = 1 - ("" + 3); var b = 1 - ("2" + 3); -var c = 1 - ("" + 3 + "4"); +var c = 1 - (3 + "4"); var d = 1 - ("2" + 3 + "4"); var e = ("" + 3) - 5; var f = ("2" + 3) - 5; -var g = ("" + 3 + "4") - 5; +var g = (3 + "4") - 5; var h = ("2" + 3 + "4") - 5; var a2 = 1 * ("" + 3); var b2 = 1 * ("2" + 3); -var c2 = 1 * ("" + 3 + "4"); +var c2 = 1 * (3 + "4"); var d2 = 1 * ("2" + 3 + "4"); var e2 = ("" + 3) * 5; var f2 = ("2" + 3) * 5; -var g2 = ("" + 3 + "4") * 5; +var g2 = (3 + "4") * 5; var h2 = ("2" + 3 + "4") * 5; var a3 = 1 & "" + 3; var b3 = 1 & "2" + 3; -var c3 = 1 & "" + 3 + "4"; +var c3 = 1 & 3 + "4"; var d3 = 1 & "2" + 3 + "4"; var e3 = "" + 3 & 5; var f3 = "2" + 3 & 5; -var g3 = "" + 3 + "4" & 5; +var g3 = 3 + "4" & 5; var h3 = "2" + 3 + "4" & 5; var a4 = 1 - ("" + (3 - 4)); var b4 = 1 - ("2" + (3 - 4)); -var c4 = 1 - ("" + (3 - 4) + "5"); +var c4 = 1 - ((3 - 4) + "5"); var d4 = 1 - ("2" + (3 - 4) + "5"); var e4 = ("" + (3 - 4)) - 6; var f4 = ("2" + (3 - 4)) - 6; -var g4 = ("" + (3 - 4) + "5") - 6; +var g4 = ((3 - 4) + "5") - 6; var h4 = ("2" + (3 - 4) + "5") - 6; var a5 = 1 - ("" + 3 * 4); var b5 = 1 - ("2" + 3 * 4); -var c5 = 1 - ("" + 3 * 4 + "5"); +var c5 = 1 - (3 * 4 + "5"); var d5 = 1 - ("2" + 3 * 4 + "5"); var e5 = ("" + 3 * 4) - 6; var f5 = ("2" + 3 * 4) - 6; -var g5 = ("" + 3 * 4 + "5") - 6; +var g5 = (3 * 4 + "5") - 6; var h5 = ("2" + 3 * 4 + "5") - 6; var a6 = 1 - ("" + (3 & 4)); var b6 = 1 - ("2" + (3 & 4)); -var c6 = 1 - ("" + (3 & 4) + "5"); +var c6 = 1 - ((3 & 4) + "5"); var d6 = 1 - ("2" + (3 & 4) + "5"); var e6 = ("" + (3 & 4)) - 6; var f6 = ("2" + (3 & 4)) - 6; -var g6 = ("" + (3 & 4) + "5") - 6; +var g6 = ((3 & 4) + "5") - 6; var h6 = ("2" + (3 & 4) + "5") - 6; var a7 = 1 * ("" + (3 - 4)); var b7 = 1 * ("2" + (3 - 4)); -var c7 = 1 * ("" + (3 - 4) + "5"); +var c7 = 1 * ((3 - 4) + "5"); var d7 = 1 * ("2" + (3 - 4) + "5"); var e7 = ("" + (3 - 4)) * 6; var f7 = ("2" + (3 - 4)) * 6; -var g7 = ("" + (3 - 4) + "5") * 6; +var g7 = ((3 - 4) + "5") * 6; var h7 = ("2" + (3 - 4) + "5") * 6; var a8 = 1 * ("" + 3 * 4); var b8 = 1 * ("2" + 3 * 4); -var c8 = 1 * ("" + 3 * 4 + "5"); +var c8 = 1 * (3 * 4 + "5"); var d8 = 1 * ("2" + 3 * 4 + "5"); var e8 = ("" + 3 * 4) * 6; var f8 = ("2" + 3 * 4) * 6; -var g8 = ("" + 3 * 4 + "5") * 6; +var g8 = (3 * 4 + "5") * 6; var h8 = ("2" + 3 * 4 + "5") * 6; var a9 = 1 * ("" + (3 & 4)); var b9 = 1 * ("2" + (3 & 4)); -var c9 = 1 * ("" + (3 & 4) + "5"); +var c9 = 1 * ((3 & 4) + "5"); var d9 = 1 * ("2" + (3 & 4) + "5"); var e9 = ("" + (3 & 4)) * 6; var f9 = ("2" + (3 & 4)) * 6; -var g9 = ("" + (3 & 4) + "5") * 6; +var g9 = ((3 & 4) + "5") * 6; var h9 = ("2" + (3 & 4) + "5") * 6; var aa = 1 & "" + (3 - 4); var ba = 1 & "2" + (3 - 4); -var ca = 1 & "" + (3 - 4) + "5"; +var ca = 1 & (3 - 4) + "5"; var da = 1 & "2" + (3 - 4) + "5"; var ea = "" + (3 - 4) & 6; var fa = "2" + (3 - 4) & 6; -var ga = "" + (3 - 4) + "5" & 6; +var ga = (3 - 4) + "5" & 6; var ha = "2" + (3 - 4) + "5" & 6; var ab = 1 & "" + 3 * 4; var bb = 1 & "2" + 3 * 4; -var cb = 1 & "" + 3 * 4 + "5"; +var cb = 1 & 3 * 4 + "5"; var db = 1 & "2" + 3 * 4 + "5"; var eb = "" + 3 * 4 & 6; var fb = "2" + 3 * 4 & 6; -var gb = "" + 3 * 4 + "5" & 6; +var gb = 3 * 4 + "5" & 6; var hb = "2" + 3 * 4 + "5" & 6; var ac = 1 & "" + (3 & 4); var bc = 1 & "2" + (3 & 4); -var cc = 1 & "" + (3 & 4) + "5"; +var cc = 1 & (3 & 4) + "5"; var dc = 1 & "2" + (3 & 4) + "5"; var ec = "" + (3 & 4) & 6; var fc = "2" + (3 & 4) & 6; -var gc = "" + (3 & 4) + "5" & 6; +var gc = (3 & 4) + "5" & 6; var hc = "2" + (3 & 4) + "5" & 6; diff --git a/tests/baselines/reference/templateStringWithEmptyLiteralPortions.js b/tests/baselines/reference/templateStringWithEmptyLiteralPortions.js index 8bc6e2c4206..e7a35d76f45 100644 --- a/tests/baselines/reference/templateStringWithEmptyLiteralPortions.js +++ b/tests/baselines/reference/templateStringWithEmptyLiteralPortions.js @@ -21,18 +21,22 @@ var j = `${ 0 }${ 0 }3`; var k = `1${ 0 }${ 0 }3`; -var l = `1${ 0 }2${ 0 }3`; +var l = `${ 0 }2${ 0 }3`; + +var m = `1${ 0 }2${ 0 }3`; + //// [templateStringWithEmptyLiteralPortions.js] var a = ""; var b = "" + 0; var c = "1" + 0; -var d = "" + 0 + "2"; +var d = 0 + "2"; var e = "1" + 0 + "2"; var f = "" + 0 + 0; var g = "1" + 0 + 0; -var h = "" + 0 + "2" + 0; +var h = 0 + "2" + 0; var i = "1" + 0 + "2" + 0; var j = "" + 0 + 0 + "3"; var k = "1" + 0 + 0 + "3"; -var l = "1" + 0 + "2" + 0 + "3"; +var l = 0 + "2" + 0 + "3"; +var m = "1" + 0 + "2" + 0 + "3"; diff --git a/tests/baselines/reference/templateStringWithEmptyLiteralPortions.types b/tests/baselines/reference/templateStringWithEmptyLiteralPortions.types index a44bab8fe44..c901d674306 100644 --- a/tests/baselines/reference/templateStringWithEmptyLiteralPortions.types +++ b/tests/baselines/reference/templateStringWithEmptyLiteralPortions.types @@ -32,6 +32,9 @@ var j = `${ 0 }${ 0 }3`; var k = `1${ 0 }${ 0 }3`; >k : string -var l = `1${ 0 }2${ 0 }3`; +var l = `${ 0 }2${ 0 }3`; >l : string +var m = `1${ 0 }2${ 0 }3`; +>m : string + diff --git a/tests/baselines/reference/templateStringWithEmptyLiteralPortionsES6.js b/tests/baselines/reference/templateStringWithEmptyLiteralPortionsES6.js index f0e827cde63..fe1bce291f0 100644 --- a/tests/baselines/reference/templateStringWithEmptyLiteralPortionsES6.js +++ b/tests/baselines/reference/templateStringWithEmptyLiteralPortionsES6.js @@ -21,7 +21,10 @@ var j = `${ 0 }${ 0 }3`; var k = `1${ 0 }${ 0 }3`; -var l = `1${ 0 }2${ 0 }3`; +var l = `${ 0 }2${ 0 }3`; + +var m = `1${ 0 }2${ 0 }3`; + //// [templateStringWithEmptyLiteralPortionsES6.js] var a = ``; @@ -35,4 +38,5 @@ var h = `${0}2${0}`; var i = `1${0}2${0}`; var j = `${0}${0}3`; var k = `1${0}${0}3`; -var l = `1${0}2${0}3`; +var l = `${0}2${0}3`; +var m = `1${0}2${0}3`; diff --git a/tests/baselines/reference/templateStringWithEmptyLiteralPortionsES6.types b/tests/baselines/reference/templateStringWithEmptyLiteralPortionsES6.types index 4074831d410..d70dd29e4da 100644 --- a/tests/baselines/reference/templateStringWithEmptyLiteralPortionsES6.types +++ b/tests/baselines/reference/templateStringWithEmptyLiteralPortionsES6.types @@ -32,6 +32,9 @@ var j = `${ 0 }${ 0 }3`; var k = `1${ 0 }${ 0 }3`; >k : string -var l = `1${ 0 }2${ 0 }3`; +var l = `${ 0 }2${ 0 }3`; >l : string +var m = `1${ 0 }2${ 0 }3`; +>m : string + diff --git a/tests/baselines/reference/typeGuardOfFormInstanceOf.types b/tests/baselines/reference/typeGuardOfFormInstanceOf.types index fb44482c86e..891e8c1bea2 100644 --- a/tests/baselines/reference/typeGuardOfFormInstanceOf.types +++ b/tests/baselines/reference/typeGuardOfFormInstanceOf.types @@ -124,9 +124,9 @@ var r2: D1 | C2 = c2Ord1 instanceof C1 && c2Ord1; // C2 | D1 >r2 : C2 | D1 >D1 : D1 >C2 : C2 ->c2Ord1 instanceof C1 && c2Ord1 : C2 | D1 +>c2Ord1 instanceof C1 && c2Ord1 : D1 >c2Ord1 instanceof C1 : boolean >c2Ord1 : C2 | D1 >C1 : typeof C1 ->c2Ord1 : C2 | D1 +>c2Ord1 : D1 diff --git a/tests/baselines/reference/typeGuardOfFormInstanceOfOnInterface.types b/tests/baselines/reference/typeGuardOfFormInstanceOfOnInterface.types index 7bf67da1500..fe23d6d303e 100644 --- a/tests/baselines/reference/typeGuardOfFormInstanceOfOnInterface.types +++ b/tests/baselines/reference/typeGuardOfFormInstanceOfOnInterface.types @@ -154,9 +154,9 @@ var r2: D1 | C2 = c2Ord1 instanceof c1 && c2Ord1; // C2 | D1 >r2 : C2 | D1 >D1 : D1 >C2 : C2 ->c2Ord1 instanceof c1 && c2Ord1 : C2 | D1 +>c2Ord1 instanceof c1 && c2Ord1 : D1 >c2Ord1 instanceof c1 : boolean >c2Ord1 : C2 | D1 >c1 : C1 ->c2Ord1 : C2 | D1 +>c2Ord1 : D1 diff --git a/tests/baselines/reference/typeGuardsWithAny.errors.txt b/tests/baselines/reference/typeGuardsWithAny.errors.txt new file mode 100644 index 00000000000..653c89c7554 --- /dev/null +++ b/tests/baselines/reference/typeGuardsWithAny.errors.txt @@ -0,0 +1,49 @@ +tests/cases/conformance/expressions/typeGuards/typeGuardsWithAny.ts(11,7): error TS2339: Property 'p' does not exist on type 'string'. +tests/cases/conformance/expressions/typeGuards/typeGuardsWithAny.ts(18,7): error TS2339: Property 'p' does not exist on type 'number'. +tests/cases/conformance/expressions/typeGuards/typeGuardsWithAny.ts(25,7): error TS2339: Property 'p' does not exist on type 'boolean'. + + +==== tests/cases/conformance/expressions/typeGuards/typeGuardsWithAny.ts (3 errors) ==== + var x: any = { p: 0 }; + + if (x instanceof Object) { + x.p; // No error, type any unaffected by instanceof type guard + } + else { + x.p; // No error, type any unaffected by instanceof type guard + } + + if (typeof x === "string") { + x.p; // Error, type any narrowed by primitive type check + ~ +!!! error TS2339: Property 'p' does not exist on type 'string'. + } + else { + x.p; // No error, type unaffected in this branch + } + + if (typeof x === "number") { + x.p; // Error, type any narrowed by primitive type check + ~ +!!! error TS2339: Property 'p' does not exist on type 'number'. + } + else { + x.p; // No error, type unaffected in this branch + } + + if (typeof x === "boolean") { + x.p; // Error, type any narrowed by primitive type check + ~ +!!! error TS2339: Property 'p' does not exist on type 'boolean'. + } + else { + x.p; // No error, type unaffected in this branch + } + + if (typeof x === "object") { + x.p; // No error, type any only affected by primitive type check + } + else { + x.p; // No error, type unaffected in this branch + } + \ No newline at end of file diff --git a/tests/baselines/reference/typeGuardsWithAny.js b/tests/baselines/reference/typeGuardsWithAny.js index 56676fb6d68..be3d64b806f 100644 --- a/tests/baselines/reference/typeGuardsWithAny.js +++ b/tests/baselines/reference/typeGuardsWithAny.js @@ -1,18 +1,71 @@ //// [typeGuardsWithAny.ts] var x: any = { p: 0 }; + if (x instanceof Object) { - x.p; // No error, type any unaffected by type guard + x.p; // No error, type any unaffected by instanceof type guard } else { - x.p; // No error, type any unaffected by type guard + x.p; // No error, type any unaffected by instanceof type guard +} + +if (typeof x === "string") { + x.p; // Error, type any narrowed by primitive type check +} +else { + x.p; // No error, type unaffected in this branch +} + +if (typeof x === "number") { + x.p; // Error, type any narrowed by primitive type check +} +else { + x.p; // No error, type unaffected in this branch +} + +if (typeof x === "boolean") { + x.p; // Error, type any narrowed by primitive type check +} +else { + x.p; // No error, type unaffected in this branch +} + +if (typeof x === "object") { + x.p; // No error, type any only affected by primitive type check +} +else { + x.p; // No error, type unaffected in this branch } //// [typeGuardsWithAny.js] var x = { p: 0 }; if (x instanceof Object) { - x.p; // No error, type any unaffected by type guard + x.p; // No error, type any unaffected by instanceof type guard } else { - x.p; // No error, type any unaffected by type guard + x.p; // No error, type any unaffected by instanceof type guard +} +if (typeof x === "string") { + x.p; // Error, type any narrowed by primitive type check +} +else { + x.p; // No error, type unaffected in this branch +} +if (typeof x === "number") { + x.p; // Error, type any narrowed by primitive type check +} +else { + x.p; // No error, type unaffected in this branch +} +if (typeof x === "boolean") { + x.p; // Error, type any narrowed by primitive type check +} +else { + x.p; // No error, type unaffected in this branch +} +if (typeof x === "object") { + x.p; // No error, type any only affected by primitive type check +} +else { + x.p; // No error, type unaffected in this branch } diff --git a/tests/baselines/reference/typeGuardsWithAny.types b/tests/baselines/reference/typeGuardsWithAny.types deleted file mode 100644 index ee628c9c249..00000000000 --- a/tests/baselines/reference/typeGuardsWithAny.types +++ /dev/null @@ -1,23 +0,0 @@ -=== tests/cases/conformance/expressions/typeGuards/typeGuardsWithAny.ts === -var x: any = { p: 0 }; ->x : any ->{ p: 0 } : { p: number; } ->p : number - -if (x instanceof Object) { ->x instanceof Object : boolean ->x : any ->Object : ObjectConstructor - - x.p; // No error, type any unaffected by type guard ->x.p : any ->x : any ->p : any -} -else { - x.p; // No error, type any unaffected by type guard ->x.p : any ->x : any ->p : any -} - diff --git a/tests/baselines/reference/typeGuardsWithInstanceOf.js b/tests/baselines/reference/typeGuardsWithInstanceOf.js new file mode 100644 index 00000000000..34af7037f0b --- /dev/null +++ b/tests/baselines/reference/typeGuardsWithInstanceOf.js @@ -0,0 +1,18 @@ +//// [typeGuardsWithInstanceOf.ts] +interface I { global: string; } +var result: I; +var result2: I; + +if (!(result instanceof RegExp)) { + result = result2; +} else if (!result.global) { +} + +//// [typeGuardsWithInstanceOf.js] +var result; +var result2; +if (!(result instanceof RegExp)) { + result = result2; +} +else if (!result.global) { +} diff --git a/tests/baselines/reference/typeGuardsWithInstanceOf.types b/tests/baselines/reference/typeGuardsWithInstanceOf.types new file mode 100644 index 00000000000..0d7b477faed --- /dev/null +++ b/tests/baselines/reference/typeGuardsWithInstanceOf.types @@ -0,0 +1,31 @@ +=== tests/cases/conformance/expressions/typeGuards/typeGuardsWithInstanceOf.ts === +interface I { global: string; } +>I : I +>global : string + +var result: I; +>result : I +>I : I + +var result2: I; +>result2 : I +>I : I + +if (!(result instanceof RegExp)) { +>!(result instanceof RegExp) : boolean +>(result instanceof RegExp) : boolean +>result instanceof RegExp : boolean +>result : I +>RegExp : RegExpConstructor + + result = result2; +>result = result2 : I +>result : I +>result2 : I + +} else if (!result.global) { +>!result.global : boolean +>result.global : string +>result : I +>global : string +} diff --git a/tests/cases/compiler/constEnumBadPropertyNames.ts b/tests/cases/compiler/constEnumBadPropertyNames.ts new file mode 100644 index 00000000000..89fc5d421ff --- /dev/null +++ b/tests/cases/compiler/constEnumBadPropertyNames.ts @@ -0,0 +1,2 @@ +const enum E { A } +var x = E["B"] \ No newline at end of file diff --git a/tests/cases/compiler/inheritedOverloadedSpecializedSignatures.ts b/tests/cases/compiler/inheritedOverloadedSpecializedSignatures.ts index c513cecb2cb..03a433382ce 100644 --- a/tests/cases/compiler/inheritedOverloadedSpecializedSignatures.ts +++ b/tests/cases/compiler/inheritedOverloadedSpecializedSignatures.ts @@ -27,10 +27,26 @@ interface B { (x: 'B2'): string[]; } -var b: B; -// non of these lines should error -var x1: string[] = b('B2'); -var x2: number = b('B1'); -var x3: boolean = b('A2'); -var x4: string = b('A1'); -var x5: void = b('A0'); \ No newline at end of file +interface C1 extends B { + (x: 'C1'): number[]; +} + +interface C2 extends B { + (x: 'C2'): boolean[]; +} + +interface C extends C1, C2 { + (x: 'C'): string; +} + +var c: C; +// none of these lines should error +var x1: string[] = c('B2'); +var x2: number = c('B1'); +var x3: boolean = c('A2'); +var x4: string = c('A1'); +var x5: void = c('A0'); +var x6: number[] = c('C1'); +var x7: boolean[] = c('C2'); +var x8: string = c('C'); +var x9: void = c('generic'); diff --git a/tests/cases/conformance/es6/defaultParameters/emitDefaultParametersFunction.ts b/tests/cases/conformance/es6/defaultParameters/emitDefaultParametersFunction.ts new file mode 100644 index 00000000000..12480939a39 --- /dev/null +++ b/tests/cases/conformance/es6/defaultParameters/emitDefaultParametersFunction.ts @@ -0,0 +1,5 @@ +// @target: es5 +function foo(x: string, y = 10) { } +function baz(x: string, y = 5, ...rest) { } +function bar(y = 10) { } +function bar1(y = 10, ...rest) { } \ No newline at end of file diff --git a/tests/cases/conformance/es6/defaultParameters/emitDefaultParametersFunctionES6.ts b/tests/cases/conformance/es6/defaultParameters/emitDefaultParametersFunctionES6.ts new file mode 100644 index 00000000000..00afc306546 --- /dev/null +++ b/tests/cases/conformance/es6/defaultParameters/emitDefaultParametersFunctionES6.ts @@ -0,0 +1,5 @@ +// @target:es6 +function foo(x: string, y = 10) { } +function baz(x: string, y = 5, ...rest) { } +function bar(y = 10) { } +function bar1(y = 10, ...rest) { } \ No newline at end of file diff --git a/tests/cases/conformance/es6/defaultParameters/emitDefaultParametersFunctionExpression.ts b/tests/cases/conformance/es6/defaultParameters/emitDefaultParametersFunctionExpression.ts new file mode 100644 index 00000000000..f8e10c0ae14 --- /dev/null +++ b/tests/cases/conformance/es6/defaultParameters/emitDefaultParametersFunctionExpression.ts @@ -0,0 +1,9 @@ +// @target: es5 +var lambda1 = (y = "hello") => { } +var lambda2 = (x: number, y = "hello") => { } +var lambda3 = (x: number, y = "hello", ...rest) => { } +var lambda4 = (y = "hello", ...rest) => { } + +var x = function (str = "hello", ...rest) { } +var y = (function (num = 10, boo = false, ...rest) { })() +var z = (function (num: number, boo = false, ...rest) { })(10) diff --git a/tests/cases/conformance/es6/defaultParameters/emitDefaultParametersFunctionExpressionES6.ts b/tests/cases/conformance/es6/defaultParameters/emitDefaultParametersFunctionExpressionES6.ts new file mode 100644 index 00000000000..aebed249a65 --- /dev/null +++ b/tests/cases/conformance/es6/defaultParameters/emitDefaultParametersFunctionExpressionES6.ts @@ -0,0 +1,9 @@ +// @target:es6 +var lambda1 = (y = "hello") => { } +var lambda2 = (x: number, y = "hello") => { } +var lambda3 = (x: number, y = "hello", ...rest) => { } +var lambda4 = (y = "hello", ...rest) => { } + +var x = function (str = "hello", ...rest) { } +var y = (function (num = 10, boo = false, ...rest) { })() +var z = (function (num: number, boo = false, ...rest) { })(10) \ No newline at end of file diff --git a/tests/cases/conformance/es6/defaultParameters/emitDefaultParametersFunctionProperty.ts b/tests/cases/conformance/es6/defaultParameters/emitDefaultParametersFunctionProperty.ts new file mode 100644 index 00000000000..8e280894af0 --- /dev/null +++ b/tests/cases/conformance/es6/defaultParameters/emitDefaultParametersFunctionProperty.ts @@ -0,0 +1,7 @@ +// @target: es5 +var obj2 = { + func1(y = 10, ...rest) { }, + func2(x = "hello") { }, + func3(x: string, z: number, y = "hello") { }, + func4(x: string, z: number, y = "hello", ...rest) { }, +} diff --git a/tests/cases/conformance/es6/defaultParameters/emitDefaultParametersFunctionPropertyES6.ts b/tests/cases/conformance/es6/defaultParameters/emitDefaultParametersFunctionPropertyES6.ts new file mode 100644 index 00000000000..cb1cfb78546 --- /dev/null +++ b/tests/cases/conformance/es6/defaultParameters/emitDefaultParametersFunctionPropertyES6.ts @@ -0,0 +1,7 @@ +// @target:es6 +var obj2 = { + func1(y = 10, ...rest) { }, + func2(x = "hello") { }, + func3(x: string, z: number, y = "hello") { }, + func4(x: string, z: number, y = "hello", ...rest) { }, +} \ No newline at end of file diff --git a/tests/cases/conformance/es6/defaultParameters/emitDefaultParametersMethod.ts b/tests/cases/conformance/es6/defaultParameters/emitDefaultParametersMethod.ts new file mode 100644 index 00000000000..be4a563836f --- /dev/null +++ b/tests/cases/conformance/es6/defaultParameters/emitDefaultParametersMethod.ts @@ -0,0 +1,17 @@ +// @target: es5 +class C { + constructor(t: boolean, z: string, x: number, y = "hello") { } + + public foo(x: string, t = false) { } + public foo1(x: string, t = false, ...rest) { } + public bar(t = false) { } + public boo(t = false, ...rest) { } +} + +class D { + constructor(y = "hello") { } +} + +class E { + constructor(y = "hello", ...rest) { } +} diff --git a/tests/cases/conformance/es6/defaultParameters/emitDefaultParametersMethodES6.ts b/tests/cases/conformance/es6/defaultParameters/emitDefaultParametersMethodES6.ts new file mode 100644 index 00000000000..886b2e9235b --- /dev/null +++ b/tests/cases/conformance/es6/defaultParameters/emitDefaultParametersMethodES6.ts @@ -0,0 +1,17 @@ +// @target:es6 +class C { + constructor(t: boolean, z: string, x: number, y = "hello") { } + + public foo(x: string, t = false) { } + public foo1(x: string, t = false, ...rest) { } + public bar(t = false) { } + public boo(t = false, ...rest) { } +} + +class D { + constructor(y = "hello") { } +} + +class E { + constructor(y = "hello", ...rest) { } +} \ No newline at end of file diff --git a/tests/cases/conformance/es6/destructuring/destructuringParameterProperties1.ts b/tests/cases/conformance/es6/destructuring/destructuringParameterProperties1.ts new file mode 100644 index 00000000000..ba73adc9fde --- /dev/null +++ b/tests/cases/conformance/es6/destructuring/destructuringParameterProperties1.ts @@ -0,0 +1,29 @@ +class C1 { + constructor(public [x, y, z]: string[]) { + } +} + +type TupleType1 = [string, number, boolean]; + +class C2 { + constructor(public [x, y, z]: TupleType1) { + } +} + +type ObjType1 = { x: number; y: string; z: boolean } + +class C3 { + constructor(public { x, y, z }: ObjType1) { + } +} + +var c1 = new C1([]); +c1 = new C1(["larry", "{curly}", "moe"]); +var useC1Properties = c1.x === c1.y && c1.y === c1.z; + +var c2 = new C2(["10", 10, !!10]); +var [c2_x, c2_y, c2_z] = [c2.x, c2.y, c2.z]; + +var c3 = new C3({x: 0, y: "", z: false}); +c3 = new C3({x: 0, "y": "y", z: true}); +var [c3_x, c3_y, c3_z] = [c3.x, c3.y, c3.z]; \ No newline at end of file diff --git a/tests/cases/conformance/es6/destructuring/destructuringParameterProperties2.ts b/tests/cases/conformance/es6/destructuring/destructuringParameterProperties2.ts new file mode 100644 index 00000000000..b7f37809154 --- /dev/null +++ b/tests/cases/conformance/es6/destructuring/destructuringParameterProperties2.ts @@ -0,0 +1,28 @@ +class C1 { + constructor(private k: number, private [a, b, c]: [number, string, boolean]) { + if ((b === undefined && c === undefined) || (this.b === undefined && this.c === undefined)) { + this.a = a || k; + } + } + + public getA() { + return this.a + } + + public getB() { + return this.b + } + + public getC() { + return this.c; + } +} + +var x = new C1(undefined, [0, undefined, ""]); +var [x_a, x_b, x_c] = [x.getA(), x.getB(), x.getC()]; + +var y = new C1(10, [0, "", true]); +var [y_a, y_b, y_c] = [y.getA(), y.getB(), y.getC()]; + +var z = new C1(10, [undefined, "", null]); +var [z_a, z_b, z_c] = [z.getA(), z.getB(), z.getC()]; diff --git a/tests/cases/conformance/es6/destructuring/destructuringParameterProperties3.ts b/tests/cases/conformance/es6/destructuring/destructuringParameterProperties3.ts new file mode 100644 index 00000000000..6819d024e6a --- /dev/null +++ b/tests/cases/conformance/es6/destructuring/destructuringParameterProperties3.ts @@ -0,0 +1,31 @@ +class C1 { + constructor(private k: T, private [a, b, c]: [T,U,V]) { + if ((b === undefined && c === undefined) || (this.b === undefined && this.c === undefined)) { + this.a = a || k; + } + } + + public getA() { + return this.a + } + + public getB() { + return this.b + } + + public getC() { + return this.c; + } +} + +var x = new C1(undefined, [0, true, ""]); +var [x_a, x_b, x_c] = [x.getA(), x.getB(), x.getC()]; + +var y = new C1(10, [0, true, true]); +var [y_a, y_b, y_c] = [y.getA(), y.getB(), y.getC()]; + +var z = new C1(10, [undefined, "", ""]); +var [z_a, z_b, z_c] = [z.getA(), z.getB(), z.getC()]; + +var w = new C1(10, [undefined, undefined, undefined]); +var [z_a, z_b, z_c] = [z.getA(), z.getB(), z.getC()]; diff --git a/tests/cases/conformance/es6/destructuring/destructuringParameterProperties4.ts b/tests/cases/conformance/es6/destructuring/destructuringParameterProperties4.ts new file mode 100644 index 00000000000..7a83e5f4d4b --- /dev/null +++ b/tests/cases/conformance/es6/destructuring/destructuringParameterProperties4.ts @@ -0,0 +1,27 @@ +// @target: es6 + +class C1 { + constructor(private k: T, protected [a, b, c]: [T,U,V]) { + if ((b === undefined && c === undefined) || (this.b === undefined && this.c === undefined)) { + this.a = a || k; + } + } + + public getA() { + return this.a + } + + public getB() { + return this.b + } + + public getC() { + return this.c; + } +} + +class C2 extends C1 { + public doSomethingWithSuperProperties() { + return `${this.a} ${this.b} ${this.c}`; + } +} diff --git a/tests/cases/conformance/es6/destructuring/destructuringParameterProperties5.ts b/tests/cases/conformance/es6/destructuring/destructuringParameterProperties5.ts new file mode 100644 index 00000000000..02f9b780ad9 --- /dev/null +++ b/tests/cases/conformance/es6/destructuring/destructuringParameterProperties5.ts @@ -0,0 +1,12 @@ +type ObjType1 = { x: number; y: string; z: boolean } +type TupleType1 = [ObjType1, number, string] + +class C1 { + constructor(public [{ x1, x2, x3 }, y, z]: TupleType1) { + var foo: any = x1 || x2 || x3 || y || z; + var bar: any = this.x1 || this.x2 || this.x3 || this.y || this.z; + } +} + +var a = new C1([{ x1: 10, x2: "", x3: true }, "", false]); +var [a_x1, a_x2, a_x3, a_y, a_z] = [a.x1, a.x2, a.x3, a.y, a.z]; \ No newline at end of file diff --git a/tests/cases/conformance/es6/destructuring/optionalBindingParameters1.ts b/tests/cases/conformance/es6/destructuring/optionalBindingParameters1.ts new file mode 100644 index 00000000000..5bdcb49e5d9 --- /dev/null +++ b/tests/cases/conformance/es6/destructuring/optionalBindingParameters1.ts @@ -0,0 +1,8 @@ + +function foo([x,y,z]?: [string, number, boolean]) { + +} + +foo(["", 0, false]); + +foo([false, 0, ""]); \ No newline at end of file diff --git a/tests/cases/conformance/es6/destructuring/optionalBindingParameters2.ts b/tests/cases/conformance/es6/destructuring/optionalBindingParameters2.ts new file mode 100644 index 00000000000..12338aeb445 --- /dev/null +++ b/tests/cases/conformance/es6/destructuring/optionalBindingParameters2.ts @@ -0,0 +1,8 @@ + +function foo({ x, y, z }?: { x: string; y: number; z: boolean }) { + +} + +foo({ x: "", y: 0, z: false }); + +foo({ x: false, y: 0, z: "" }); \ No newline at end of file diff --git a/tests/cases/conformance/es6/destructuring/optionalBindingParametersInOverloads1.ts b/tests/cases/conformance/es6/destructuring/optionalBindingParametersInOverloads1.ts new file mode 100644 index 00000000000..82aa49d346a --- /dev/null +++ b/tests/cases/conformance/es6/destructuring/optionalBindingParametersInOverloads1.ts @@ -0,0 +1,9 @@ + +function foo([x, y, z] ?: [string, number, boolean]); +function foo(...rest: any[]) { + +} + +foo(["", 0, false]); + +foo([false, 0, ""]); \ No newline at end of file diff --git a/tests/cases/conformance/es6/destructuring/optionalBindingParametersInOverloads2.ts b/tests/cases/conformance/es6/destructuring/optionalBindingParametersInOverloads2.ts new file mode 100644 index 00000000000..bbe763b3008 --- /dev/null +++ b/tests/cases/conformance/es6/destructuring/optionalBindingParametersInOverloads2.ts @@ -0,0 +1,9 @@ + +function foo({ x, y, z }?: { x: string; y: number; z: boolean }); +function foo(...rest: any[]) { + +} + +foo({ x: "", y: 0, z: false }); + +foo({ x: false, y: 0, z: "" }); \ No newline at end of file diff --git a/tests/cases/conformance/es6/restParameters/emitRestParametersFunction.ts b/tests/cases/conformance/es6/restParameters/emitRestParametersFunction.ts new file mode 100644 index 00000000000..ee170d2bcb9 --- /dev/null +++ b/tests/cases/conformance/es6/restParameters/emitRestParametersFunction.ts @@ -0,0 +1,3 @@ +// @target: es5 +function bar(...rest) { } +function foo(x: number, y: string, ...rest) { } \ No newline at end of file diff --git a/tests/cases/conformance/es6/restParameters/emitRestParametersFunctionES6.ts b/tests/cases/conformance/es6/restParameters/emitRestParametersFunctionES6.ts new file mode 100644 index 00000000000..366905d764b --- /dev/null +++ b/tests/cases/conformance/es6/restParameters/emitRestParametersFunctionES6.ts @@ -0,0 +1,3 @@ +// @target: es6 +function bar(...rest) { } +function foo(x: number, y: string, ...rest) { } \ No newline at end of file diff --git a/tests/cases/conformance/es6/restParameters/emitRestParametersFunctionExpression.ts b/tests/cases/conformance/es6/restParameters/emitRestParametersFunctionExpression.ts new file mode 100644 index 00000000000..a9ddf83c816 --- /dev/null +++ b/tests/cases/conformance/es6/restParameters/emitRestParametersFunctionExpression.ts @@ -0,0 +1,5 @@ +// @target: es5 +var funcExp = (...rest) => { } +var funcExp1 = (X: number, ...rest) => { } +var funcExp2 = function (...rest) { } +var funcExp3 = (function (...rest) { })() diff --git a/tests/cases/conformance/es6/restParameters/emitRestParametersFunctionExpressionES6.ts b/tests/cases/conformance/es6/restParameters/emitRestParametersFunctionExpressionES6.ts new file mode 100644 index 00000000000..310dcfd1557 --- /dev/null +++ b/tests/cases/conformance/es6/restParameters/emitRestParametersFunctionExpressionES6.ts @@ -0,0 +1,5 @@ +// @target: es6 +var funcExp = (...rest) => { } +var funcExp1 = (X: number, ...rest) => { } +var funcExp2 = function (...rest) { } +var funcExp3 = (function (...rest) { })() \ No newline at end of file diff --git a/tests/cases/conformance/es6/restParameters/emitRestParametersFunctionProperty.ts b/tests/cases/conformance/es6/restParameters/emitRestParametersFunctionProperty.ts new file mode 100644 index 00000000000..c8a8ed16e7b --- /dev/null +++ b/tests/cases/conformance/es6/restParameters/emitRestParametersFunctionProperty.ts @@ -0,0 +1,8 @@ +// @target: es5 +var obj: { + func1: (...rest) => void +} + +var obj2 = { + func(...rest) { } +} \ No newline at end of file diff --git a/tests/cases/conformance/es6/restParameters/emitRestParametersFunctionPropertyES6.ts b/tests/cases/conformance/es6/restParameters/emitRestParametersFunctionPropertyES6.ts new file mode 100644 index 00000000000..34bb0cae6b7 --- /dev/null +++ b/tests/cases/conformance/es6/restParameters/emitRestParametersFunctionPropertyES6.ts @@ -0,0 +1,8 @@ +// @target: es6 +var obj: { + func1: (...rest) => void +} + +var obj2 = { + func(...rest) { } +} \ No newline at end of file diff --git a/tests/cases/conformance/es6/restParameters/emitRestParametersMethod.ts b/tests/cases/conformance/es6/restParameters/emitRestParametersMethod.ts new file mode 100644 index 00000000000..6b9e70fd196 --- /dev/null +++ b/tests/cases/conformance/es6/restParameters/emitRestParametersMethod.ts @@ -0,0 +1,14 @@ +// @target: es5 +class C { + constructor(name: string, ...rest) { } + + public bar(...rest) { } + public foo(x: number, ...rest) { } +} + +class D { + constructor(...rest) { } + + public bar(...rest) { } + public foo(x: number, ...rest) { } +} \ No newline at end of file diff --git a/tests/cases/conformance/es6/restParameters/emitRestParametersMethodES6.ts b/tests/cases/conformance/es6/restParameters/emitRestParametersMethodES6.ts new file mode 100644 index 00000000000..df2f2293c75 --- /dev/null +++ b/tests/cases/conformance/es6/restParameters/emitRestParametersMethodES6.ts @@ -0,0 +1,14 @@ +// @target: es6 +class C { + constructor(name: string, ...rest) { } + + public bar(...rest) { } + public foo(x: number, ...rest) { } +} + +class D { + constructor(...rest) { } + + public bar(...rest) { } + public foo(x: number, ...rest) { } +} diff --git a/tests/cases/conformance/es6/templates/templateStringWithEmptyLiteralPortions.ts b/tests/cases/conformance/es6/templates/templateStringWithEmptyLiteralPortions.ts index 11dca4caf77..9191ca1934c 100644 --- a/tests/cases/conformance/es6/templates/templateStringWithEmptyLiteralPortions.ts +++ b/tests/cases/conformance/es6/templates/templateStringWithEmptyLiteralPortions.ts @@ -20,4 +20,6 @@ var j = `${ 0 }${ 0 }3`; var k = `1${ 0 }${ 0 }3`; -var l = `1${ 0 }2${ 0 }3`; \ No newline at end of file +var l = `${ 0 }2${ 0 }3`; + +var m = `1${ 0 }2${ 0 }3`; diff --git a/tests/cases/conformance/es6/templates/templateStringWithEmptyLiteralPortionsES6.ts b/tests/cases/conformance/es6/templates/templateStringWithEmptyLiteralPortionsES6.ts index 183da57dd45..ff178d22432 100644 --- a/tests/cases/conformance/es6/templates/templateStringWithEmptyLiteralPortionsES6.ts +++ b/tests/cases/conformance/es6/templates/templateStringWithEmptyLiteralPortionsES6.ts @@ -21,4 +21,6 @@ var j = `${ 0 }${ 0 }3`; var k = `1${ 0 }${ 0 }3`; -var l = `1${ 0 }2${ 0 }3`; \ No newline at end of file +var l = `${ 0 }2${ 0 }3`; + +var m = `1${ 0 }2${ 0 }3`; diff --git a/tests/cases/conformance/expressions/contextualTyping/parenthesizedContexualTyping1.ts b/tests/cases/conformance/expressions/contextualTyping/parenthesizedContexualTyping1.ts new file mode 100644 index 00000000000..49dfe75ccc6 --- /dev/null +++ b/tests/cases/conformance/expressions/contextualTyping/parenthesizedContexualTyping1.ts @@ -0,0 +1,29 @@ + +function fun(g: (x: T) => T, x: T): T; +function fun(g: (x: T) => T, h: (y: T) => T, x: T): T; +function fun(g: (x: T) => T, x: T): T { + return g(x); +} + +var a = fun(x => x, 10); +var b = fun((x => x), 10); +var c = fun(((x => x)), 10); +var d = fun((((x => x))), 10); + +var e = fun(x => x, x => x, 10); +var f = fun((x => x), (x => x), 10); +var g = fun(((x => x)), ((x => x)), 10); +var h = fun((((x => x))), ((x => x)), 10); + +// Ternaries in parens +var i = fun((Math.random() < 0.5 ? x => x : x => undefined), 10); +var j = fun((Math.random() < 0.5 ? (x => x) : (x => undefined)), 10); +var k = fun((Math.random() < 0.5 ? (x => x) : (x => undefined)), x => x, 10); +var l = fun(((Math.random() < 0.5 ? ((x => x)) : ((x => undefined)))), ((x => x)), 10); + +var lambda1: (x: number) => number = x => x; +var lambda2: (x: number) => number = (x => x); + +type ObjType = { x: (p: number) => string; y: (p: string) => number }; +var obj1: ObjType = { x: x => (x, undefined), y: y => (y, undefined) }; +var obj2: ObjType = ({ x: x => (x, undefined), y: y => (y, undefined) }); \ No newline at end of file diff --git a/tests/cases/conformance/expressions/contextualTyping/parenthesizedContexualTyping2.ts b/tests/cases/conformance/expressions/contextualTyping/parenthesizedContexualTyping2.ts new file mode 100644 index 00000000000..15acbf3e134 --- /dev/null +++ b/tests/cases/conformance/expressions/contextualTyping/parenthesizedContexualTyping2.ts @@ -0,0 +1,36 @@ +// These tests ensure that in cases where it may *appear* that a value has a type, +// they actually are properly being contextually typed. The way we test this is +// that we invoke contextually typed arguments with type arguments. +// Since 'any' cannot be invoked with type arguments, we should get errors +// back if contextual typing is not taking effect. + +type FuncType = (x: (p: T) => T) => typeof x; + +function fun(f: FuncType, x: T): T; +function fun(f: FuncType, g: FuncType, x: T): T; +function fun(...rest: any[]): T { + return undefined; +} + +var a = fun(x => { x(undefined); return x; }, 10); +var b = fun((x => { x(undefined); return x; }), 10); +var c = fun(((x => { x(undefined); return x; })), 10); +var d = fun((((x => { x(undefined); return x; }))), 10); + +var e = fun(x => { x(undefined); return x; }, x => { x(undefined); return x; }, 10); +var f = fun((x => { x(undefined); return x; }),(x => { x(undefined); return x; }), 10); +var g = fun(((x => { x(undefined); return x; })),((x => { x(undefined); return x; })), 10); +var h = fun((((x => { x(undefined); return x; }))),((x => { x(undefined); return x; })), 10); + +// Ternaries in parens +var i = fun((Math.random() < 0.5 ? x => { x(undefined); return x; } : x => undefined), 10); +var j = fun((Math.random() < 0.5 ? (x => { x(undefined); return x; }) : (x => undefined)), 10); +var k = fun((Math.random() < 0.5 ? (x => { x(undefined); return x; }) : (x => undefined)), x => { x(undefined); return x; }, 10); +var l = fun(((Math.random() < 0.5 ? ((x => { x(undefined); return x; })) : ((x => undefined)))),((x => { x(undefined); return x; })), 10); + +var lambda1: FuncType = x => { x(undefined); return x; }; +var lambda2: FuncType = (x => { x(undefined); return x; }); + +type ObjType = { x: (p: number) => string; y: (p: string) => number }; +var obj1: ObjType = { x: x => (x, undefined), y: y => (y, undefined) }; +var obj2: ObjType = ({ x: x => (x, undefined), y: y => (y, undefined) }); \ No newline at end of file diff --git a/tests/cases/conformance/expressions/contextualTyping/parenthesizedContexualTyping3.ts b/tests/cases/conformance/expressions/contextualTyping/parenthesizedContexualTyping3.ts new file mode 100644 index 00000000000..004617c3d81 --- /dev/null +++ b/tests/cases/conformance/expressions/contextualTyping/parenthesizedContexualTyping3.ts @@ -0,0 +1,21 @@ +// @target: ES6 + +// Contextual typing for parenthesized substitution expressions in tagged templates. + +/** + * tempFun - Can't have fun for too long. + */ +function tempFun(tempStrs: TemplateStringsArray, g: (x: T) => T, x: T): T; +function tempFun(tempStrs: TemplateStringsArray, g: (x: T) => T, h: (y: T) => T, x: T): T; +function tempFun(tempStrs: TemplateStringsArray, g: (x: T) => T, x: T): T { + return g(x); +} + +var a = tempFun `${ x => x } ${ 10 }` +var b = tempFun `${ (x => x) } ${ 10 }` +var c = tempFun `${ ((x => x)) } ${ 10 }` +var d = tempFun `${ x => x } ${ x => x } ${ 10 }` +var e = tempFun `${ x => x } ${ (x => x) } ${ 10 }` +var f = tempFun `${ x => x } ${ ((x => x)) } ${ 10 }` +var g = tempFun `${ (x => x) } ${ (((x => x))) } ${ 10 }` +var h = tempFun `${ (x => x) } ${ (((x => x))) } ${ undefined }` \ No newline at end of file diff --git a/tests/cases/conformance/expressions/contextualTyping/taggedTemplateContextualTyping1.ts b/tests/cases/conformance/expressions/contextualTyping/taggedTemplateContextualTyping1.ts index c15d911ee52..84562f788f3 100644 --- a/tests/cases/conformance/expressions/contextualTyping/taggedTemplateContextualTyping1.ts +++ b/tests/cases/conformance/expressions/contextualTyping/taggedTemplateContextualTyping1.ts @@ -12,6 +12,7 @@ function tempTag1(...rest: any[]): T { // Otherwise, the arrow functions' parameters will be typed as 'any', // and it is an error to invoke an any-typed value with type arguments, // so this test will error. +tempTag1 `${ x => { x(undefined); return x; } }${ 10 }`; tempTag1 `${ x => { x(undefined); return x; } }${ y => { y(undefined); return y; } }${ 10 }`; tempTag1 `${ x => { x(undefined); return x; } }${ (y: (p: T) => T) => { y(undefined); return y } }${ undefined }`; tempTag1 `${ (x: (p: T) => T) => { x(undefined); return x; } }${ y => { y(undefined); return y; } }${ undefined }`; diff --git a/tests/cases/conformance/expressions/typeGuards/TypeGuardWithArrayUnion.ts b/tests/cases/conformance/expressions/typeGuards/TypeGuardWithArrayUnion.ts new file mode 100644 index 00000000000..8884754b480 --- /dev/null +++ b/tests/cases/conformance/expressions/typeGuards/TypeGuardWithArrayUnion.ts @@ -0,0 +1,9 @@ +class Message { + value: string; +} + +function saySize(message: Message | Message[]) { + if (message instanceof Array) { + return message.length; // Should have type Message[] here + } +} diff --git a/tests/cases/conformance/expressions/typeGuards/typeGuardsWithAny.ts b/tests/cases/conformance/expressions/typeGuards/typeGuardsWithAny.ts index e7e756ea8e0..a6379bf95b0 100644 --- a/tests/cases/conformance/expressions/typeGuards/typeGuardsWithAny.ts +++ b/tests/cases/conformance/expressions/typeGuards/typeGuardsWithAny.ts @@ -1,7 +1,36 @@ var x: any = { p: 0 }; + if (x instanceof Object) { - x.p; // No error, type any unaffected by type guard + x.p; // No error, type any unaffected by instanceof type guard } else { - x.p; // No error, type any unaffected by type guard + x.p; // No error, type any unaffected by instanceof type guard +} + +if (typeof x === "string") { + x.p; // Error, type any narrowed by primitive type check +} +else { + x.p; // No error, type unaffected in this branch +} + +if (typeof x === "number") { + x.p; // Error, type any narrowed by primitive type check +} +else { + x.p; // No error, type unaffected in this branch +} + +if (typeof x === "boolean") { + x.p; // Error, type any narrowed by primitive type check +} +else { + x.p; // No error, type unaffected in this branch +} + +if (typeof x === "object") { + x.p; // No error, type any only affected by primitive type check +} +else { + x.p; // No error, type unaffected in this branch } diff --git a/tests/cases/conformance/expressions/typeGuards/typeGuardsWithInstanceOf.ts b/tests/cases/conformance/expressions/typeGuards/typeGuardsWithInstanceOf.ts new file mode 100644 index 00000000000..2750eb96ebf --- /dev/null +++ b/tests/cases/conformance/expressions/typeGuards/typeGuardsWithInstanceOf.ts @@ -0,0 +1,8 @@ +interface I { global: string; } +var result: I; +var result2: I; + +if (!(result instanceof RegExp)) { + result = result2; +} else if (!result.global) { +} \ No newline at end of file diff --git a/tests/cases/fourslash/assertContextualType.ts b/tests/cases/fourslash/assertContextualType.ts index 36a59583825..6ee8861ee8c 100644 --- a/tests/cases/fourslash/assertContextualType.ts +++ b/tests/cases/fourslash/assertContextualType.ts @@ -2,8 +2,5 @@ ////<(aa: number) =>void >(function myFn(b/**/b) { }); -// this line triggers a semantic/syntactic error check, remove line when 788570 is fixed -edit.insert(''); - goTo.marker(); -verify.quickInfoIs('(parameter) bb: any'); \ No newline at end of file +verify.quickInfoIs('(parameter) bb: number'); \ No newline at end of file diff --git a/tests/cases/fourslash/contextualTyping.ts b/tests/cases/fourslash/contextualTyping.ts index 13fb4dc2450..c363302f7a1 100644 --- a/tests/cases/fourslash/contextualTyping.ts +++ b/tests/cases/fourslash/contextualTyping.ts @@ -212,9 +212,9 @@ verify.quickInfoIs("(parameter) i: number"); goTo.marker('7'); verify.quickInfoIs("(var) c3t1: (s: string) => string"); goTo.marker('8'); -verify.quickInfoIs("(parameter) s: any"); +verify.quickInfoIs("(parameter) s: string"); goTo.marker('9'); -verify.quickInfoIs("(parameter) s: any"); +verify.quickInfoIs("(parameter) s: string"); goTo.marker('10'); verify.quickInfoIs("(var) c3t2: IFoo"); goTo.marker('11'); @@ -254,11 +254,11 @@ verify.quickInfoIs("(property) foo: IFoo"); goTo.marker('29'); verify.quickInfoIs("(var) c3t13: IFoo"); goTo.marker('30'); -verify.quickInfoIs("(property) f: (i: any, s: any) => any"); +verify.quickInfoIs("(property) f: (i: number, s: string) => string"); goTo.marker('31'); -verify.quickInfoIs("(parameter) i: any"); +verify.quickInfoIs("(parameter) i: number"); goTo.marker('32'); -verify.quickInfoIs("(parameter) s: any"); +verify.quickInfoIs("(parameter) s: string"); goTo.marker('33'); verify.quickInfoIs("(var) c3t14: IFoo"); goTo.marker('34'); @@ -286,7 +286,7 @@ verify.quickInfoIs("(var) c7t2: IFoo[]"); goTo.marker('45'); verify.quickInfoIs("(property) t1: (s: string) => string"); goTo.marker('46'); -verify.quickInfoIs("(parameter) s: any"); +verify.quickInfoIs("(parameter) s: string"); goTo.marker('47'); verify.quickInfoIs("(property) t2: IFoo"); goTo.marker('48'); @@ -326,11 +326,11 @@ verify.quickInfoIs("(property) foo: IFoo"); goTo.marker('65'); verify.quickInfoIs("(property) t13: IFoo"); goTo.marker('66'); -verify.quickInfoIs("(property) f: (i: any, s: any) => any"); +verify.quickInfoIs("(property) f: (i: number, s: string) => string"); goTo.marker('67'); -verify.quickInfoIs("(parameter) i: any"); +verify.quickInfoIs("(parameter) i: number"); goTo.marker('68'); -verify.quickInfoIs("(parameter) s: any"); +verify.quickInfoIs("(parameter) s: string"); goTo.marker('69'); verify.quickInfoIs("(property) t14: IFoo"); goTo.marker('70'); @@ -346,7 +346,7 @@ verify.quickInfoIs("(parameter) n: number"); goTo.marker('75'); verify.quickInfoIs("(var) c12t1: (s: string) => string"); goTo.marker('76'); -verify.quickInfoIs("(parameter) s: any"); +verify.quickInfoIs("(parameter) s: string"); goTo.marker('77'); verify.quickInfoIs("(var) c12t2: IFoo"); goTo.marker('78'); @@ -386,11 +386,11 @@ verify.quickInfoIs("(property) foo: IFoo"); goTo.marker('95'); verify.quickInfoIs("(var) c12t13: IFoo"); goTo.marker('96'); -verify.quickInfoIs("(property) f: (i: any, s: any) => any"); +verify.quickInfoIs("(property) f: (i: number, s: string) => string"); goTo.marker('97'); -verify.quickInfoIs("(parameter) i: any"); +verify.quickInfoIs("(parameter) i: number"); goTo.marker('98'); -verify.quickInfoIs("(parameter) s: any"); +verify.quickInfoIs("(parameter) s: string"); goTo.marker('99'); verify.quickInfoIs("(var) c12t14: IFoo"); goTo.marker('100'); diff --git a/tests/cases/fourslash/formatEmptyParamList.ts b/tests/cases/fourslash/formatEmptyParamList.ts new file mode 100644 index 00000000000..5b207581d61 --- /dev/null +++ b/tests/cases/fourslash/formatEmptyParamList.ts @@ -0,0 +1,5 @@ +/// +////function f( f: function){/*1*/ +goTo.marker("1"); +edit.insert("}"); +verify.currentLineContentIs("function f(f: function){ }") \ No newline at end of file diff --git a/tests/cases/fourslash/overloadOnConstCallSignature.ts b/tests/cases/fourslash/overloadOnConstCallSignature.ts index 52e0f3c02e0..7e8075e3652 100644 --- a/tests/cases/fourslash/overloadOnConstCallSignature.ts +++ b/tests/cases/fourslash/overloadOnConstCallSignature.ts @@ -11,8 +11,8 @@ goTo.marker('1'); verify.signatureHelpCountIs(4); -verify.currentSignatureHelpIs('foo(name: string): string'); +verify.currentSignatureHelpIs('foo(name: \'order\'): string'); edit.insert('"hi"'); goTo.marker('2'); -verify.quickInfoIs('(var) x: string'); \ No newline at end of file +verify.quickInfoIs('(var) x: string'); diff --git a/tests/perfsys.ts b/tests/perfsys.ts index d3f7ff2ab02..143d0d637d4 100644 --- a/tests/perfsys.ts +++ b/tests/perfsys.ts @@ -1,4 +1,6 @@ /// +/// + module perftest { interface IOLog { @@ -10,24 +12,24 @@ module perftest { getOut(): string; } - export var readFile = sys.readFile; - var writeFile = sys.writeFile; - export var write = sys.write; - var resolvePath = sys.resolvePath; - export var getExecutingFilePath = sys.getExecutingFilePath; - export var getCurrentDirectory = sys.getCurrentDirectory; - var exit = sys.exit; + export var readFile = ts.sys.readFile; + var writeFile = ts.sys.writeFile; + export var write = ts.sys.write; + var resolvePath = ts.sys.resolvePath; + export var getExecutingFilePath = ts.sys.getExecutingFilePath; + export var getCurrentDirectory = ts.sys.getCurrentDirectory; + var exit = ts.sys.exit; - var args = sys.args; + var args = ts.sys.args; // augment sys so first ts.executeCommandLine call will be finish silently - sys.write = (s: string) => { }; - sys.exit = (code: number) => { }; - sys.args = [] + ts.sys.write = (s: string) => { }; + ts.sys.exit = (code: number) => { }; + ts.sys.args = [] export function restoreSys() { - sys.args = args; - sys.write = write; + ts.sys.args = args; + ts.sys.write = write; } export function hasLogIOFlag() { @@ -45,7 +47,7 @@ module perftest { var resolvePathLog: ts.Map = {}; export function interceptIO() { - sys.resolvePath = (s) => { + ts.sys.resolvePath = (s) => { var result = resolvePath(s); resolvePathLog[s] = result; return result; @@ -68,21 +70,21 @@ module perftest { var files: ts.Map = {}; log.fileNames.forEach(f => { files[f] = readFile(f); }) - sys.createDirectory = (s: string) => { }; - sys.directoryExists = (s: string) => true; - sys.fileExists = (s: string) => true; + ts.sys.createDirectory = (s: string) => { }; + ts.sys.directoryExists = (s: string) => true; + ts.sys.fileExists = (s: string) => true; - var currentDirectory = sys.getCurrentDirectory(); - sys.getCurrentDirectory = () => currentDirectory; + var currentDirectory = ts.sys.getCurrentDirectory(); + ts.sys.getCurrentDirectory = () => currentDirectory; - var executingFilePath = sys.getExecutingFilePath(); - sys.getExecutingFilePath = () => executingFilePath; + var executingFilePath = ts.sys.getExecutingFilePath(); + ts.sys.getExecutingFilePath = () => executingFilePath; - sys.readFile = (s: string) => { + ts.sys.readFile = (s: string) => { return files[s]; } - sys.resolvePath = (s: string) => { + ts.sys.resolvePath = (s: string) => { var path = log.resolvePath[s]; if (!path) { throw new Error("Unexpected path '" + s + "'"); @@ -90,11 +92,11 @@ module perftest { return path } - sys.writeFile = (path: string, data: string) => { }; + ts.sys.writeFile = (path: string, data: string) => { }; var out: string = ""; - sys.write = (s: string) => { out += s; }; + ts.sys.write = (s: string) => { out += s; }; return { getOut: () => out, diff --git a/tests/perftsc.ts b/tests/perftsc.ts index e42a6710be4..e0189896a15 100644 --- a/tests/perftsc.ts +++ b/tests/perftsc.ts @@ -13,9 +13,9 @@ if (perftest.hasLogIOFlag()) { getDefaultLibFilename: () => ts.combinePaths(ts.getDirectoryPath(ts.normalizePath(perftest.getExecutingFilePath())), "lib.d.ts"), writeFile: (f: string, content: string) => { throw new Error("Unexpected operation: writeFile"); }, getCurrentDirectory: () => perftest.getCurrentDirectory(), - getCanonicalFileName: ts.getCanonicalFileName, - useCaseSensitiveFileNames: () => sys.useCaseSensitiveFileNames, - getNewLine: () => sys.newLine + getCanonicalFileName: (f: string) => ts.sys.useCaseSensitiveFileNames ? f : f.toLowerCase(), + useCaseSensitiveFileNames: () => ts.sys.useCaseSensitiveFileNames, + getNewLine: () => ts.sys.newLine }; var commandLine = ts.parseCommandLine(perftest.getArgsWithoutLogIOFlag());