@@ -3265,7 +3265,7 @@ namespace ts {
32653265
32663266 function hasVisibleDeclarations(symbol: Symbol, shouldComputeAliasToMakeVisible: boolean): SymbolVisibilityResult | undefined {
32673267 let aliasesToMakeVisible: LateVisibilityPaintedStatement[] | undefined;
3268- if (!every(symbol.declarations, getIsDeclarationVisible)) {
3268+ if (!every(filter( symbol.declarations, d => d.kind !== SyntaxKind.Identifier) , getIsDeclarationVisible)) {
32693269 return undefined;
32703270 }
32713271 return { accessibility: SymbolAccessibility.Accessible, aliasesToMakeVisible };
@@ -5483,7 +5483,7 @@ namespace ts {
54835483 function getTypeFromObjectBindingPattern(pattern: ObjectBindingPattern, includePatternInType: boolean, reportErrors: boolean): Type {
54845484 const members = createSymbolTable();
54855485 let stringIndexInfo: IndexInfo | undefined;
5486- let objectFlags = ObjectFlags.ObjectLiteral | ObjectFlags.ContainsObjectLiteral ;
5486+ let objectFlags = ObjectFlags.ObjectLiteral | ObjectFlags.ContainsObjectOrArrayLiteral ;
54875487 forEach(pattern.elements, e => {
54885488 const name = e.propertyName || <Identifier>e.name;
54895489 if (e.dotDotDotToken) {
@@ -10805,7 +10805,7 @@ namespace ts {
1080510805 emptyArray,
1080610806 getIndexInfoWithReadonly(stringIndexInfo, readonly),
1080710807 getIndexInfoWithReadonly(numberIndexInfo, readonly));
10808- spread.objectFlags |= ObjectFlags.ObjectLiteral | ObjectFlags.ContainsObjectLiteral | ObjectFlags.ContainsSpread | objectFlags;
10808+ spread.objectFlags |= ObjectFlags.ObjectLiteral | ObjectFlags.ContainsObjectOrArrayLiteral | ObjectFlags.ContainsSpread | objectFlags;
1080910809 return spread;
1081010810 }
1081110811
@@ -14442,7 +14442,7 @@ namespace ts {
1444214442 if (propType) {
1444314443 return propType;
1444414444 }
14445- if (everyType(type, isTupleType) && !everyType(type, t => !(<TupleTypeReference>t).target.hasRestElement) ) {
14445+ if (everyType(type, isTupleType)) {
1444614446 return mapType(type, t => getRestTypeOfTupleType(<TupleTypeReference>t) || undefinedType);
1444714447 }
1444814448 return undefined;
@@ -15646,12 +15646,16 @@ namespace ts {
1564615646 return !!(getObjectFlags(type) & ObjectFlags.ObjectLiteral);
1564715647 }
1564815648
15649- function widenObjectLiteralCandidates(candidates: Type[]): Type[] {
15649+ function isObjectOrArrayLiteralType(type: Type) {
15650+ return !!(getObjectFlags(type) & (ObjectFlags.ObjectLiteral | ObjectFlags.ArrayLiteral));
15651+ }
15652+
15653+ function unionObjectAndArrayLiteralCandidates(candidates: Type[]): Type[] {
1565015654 if (candidates.length > 1) {
15651- const objectLiterals = filter(candidates, isObjectLiteralType );
15655+ const objectLiterals = filter(candidates, isObjectOrArrayLiteralType );
1565215656 if (objectLiterals.length) {
15653- const objectLiteralsType = getWidenedType( getUnionType(objectLiterals, UnionReduction.Subtype) );
15654- return concatenate(filter(candidates, t => !isObjectLiteralType (t)), [objectLiteralsType ]);
15657+ const literalsType = getUnionType(objectLiterals, UnionReduction.Subtype);
15658+ return concatenate(filter(candidates, t => !isObjectOrArrayLiteralType (t)), [literalsType ]);
1565515659 }
1565615660 }
1565715661 return candidates;
@@ -15662,8 +15666,8 @@ namespace ts {
1566215666 }
1566315667
1566415668 function getCovariantInference(inference: InferenceInfo, signature: Signature) {
15665- // Extract all object literal types and replace them with a single widened and normalized type.
15666- const candidates = widenObjectLiteralCandidates (inference.candidates!);
15669+ // Extract all object and array literal types and replace them with a single widened and normalized type.
15670+ const candidates = unionObjectAndArrayLiteralCandidates (inference.candidates!);
1566715671 // We widen inferred literal types if
1566815672 // all inferences were made to top-level occurrences of the type parameter, and
1566915673 // the type parameter has no constraint or its constraint includes no primitive or literal types, and
@@ -19149,22 +19153,34 @@ namespace ts {
1914919153 const minLength = elementCount - (hasRestElement ? 1 : 0);
1915019154 // If array literal is actually a destructuring pattern, mark it as an implied type. We do this such
1915119155 // that we get the same behavior for "var [x, y] = []" and "[x, y] = []".
19152- let tupleResult: Type | undefined ;
19156+ let tupleResult;
1915319157 if (inDestructuringPattern && minLength > 0) {
1915419158 const type = cloneTypeReference(<TypeReference>createTupleType(elementTypes, minLength, hasRestElement));
1915519159 type.pattern = node;
1915619160 return type;
1915719161 }
1915819162 else if (tupleResult = getArrayLiteralTupleTypeIfApplicable(elementTypes, contextualType, hasRestElement, elementCount, inConstContext)) {
19159- return tupleResult;
19163+ return createArrayLiteralType( tupleResult) ;
1916019164 }
1916119165 else if (forceTuple) {
19162- return createTupleType(elementTypes, minLength, hasRestElement);
19166+ return createArrayLiteralType( createTupleType(elementTypes, minLength, hasRestElement) );
1916319167 }
1916419168 }
19165- return createArrayType(elementTypes.length ?
19169+ return createArrayLiteralType( createArrayType(elementTypes.length ?
1916619170 getUnionType(elementTypes, UnionReduction.Subtype) :
19167- strictNullChecks ? implicitNeverType : undefinedWideningType, inConstContext);
19171+ strictNullChecks ? implicitNeverType : undefinedWideningType, inConstContext));
19172+ }
19173+
19174+ function createArrayLiteralType(type: ObjectType) {
19175+ if (!(getObjectFlags(type) & ObjectFlags.Reference)) {
19176+ return type;
19177+ }
19178+ let literalType = (<TypeReference>type).literalType;
19179+ if (!literalType) {
19180+ literalType = (<TypeReference>type).literalType = cloneTypeReference(<TypeReference>type);
19181+ literalType.objectFlags |= ObjectFlags.ArrayLiteral | ObjectFlags.ContainsObjectOrArrayLiteral;
19182+ }
19183+ return literalType;
1916819184 }
1916919185
1917019186 function getArrayLiteralTupleTypeIfApplicable(elementTypes: Type[], contextualType: Type | undefined, hasRestElement: boolean, elementCount = elementTypes.length, readonly = false) {
@@ -19449,7 +19465,7 @@ namespace ts {
1944919465 const stringIndexInfo = hasComputedStringProperty ? getObjectLiteralIndexInfo(node, offset, propertiesArray, IndexKind.String) : undefined;
1945019466 const numberIndexInfo = hasComputedNumberProperty ? getObjectLiteralIndexInfo(node, offset, propertiesArray, IndexKind.Number) : undefined;
1945119467 const result = createAnonymousType(node.symbol, propertiesTable, emptyArray, emptyArray, stringIndexInfo, numberIndexInfo);
19452- result.objectFlags |= objectFlags | ObjectFlags.ObjectLiteral | ObjectFlags.ContainsObjectLiteral ;
19468+ result.objectFlags |= objectFlags | ObjectFlags.ObjectLiteral | ObjectFlags.ContainsObjectOrArrayLiteral ;
1945319469 if (isJSObjectLiteral) {
1945419470 result.objectFlags |= ObjectFlags.JSLiteral;
1945519471 }
@@ -19645,7 +19661,7 @@ namespace ts {
1964519661 function createJsxAttributesType() {
1964619662 objectFlags |= freshObjectLiteralFlag;
1964719663 const result = createAnonymousType(attributes.symbol, attributesTable, emptyArray, emptyArray, /*stringIndexInfo*/ undefined, /*numberIndexInfo*/ undefined);
19648- result.objectFlags |= objectFlags | ObjectFlags.ObjectLiteral | ObjectFlags.ContainsObjectLiteral ;
19664+ result.objectFlags |= objectFlags | ObjectFlags.ObjectLiteral | ObjectFlags.ContainsObjectOrArrayLiteral ;
1964919665 return result;
1965019666 }
1965119667 }
@@ -21398,7 +21414,8 @@ namespace ts {
2139821414 reorderCandidates(signatures, candidates);
2139921415 if (!candidates.length) {
2140021416 if (reportErrors) {
21401- diagnostics.add(createDiagnosticForNode(node, Diagnostics.Call_target_does_not_contain_any_signatures));
21417+ const errorNode = getCallErrorNode(node);
21418+ diagnostics.add(createDiagnosticForNode(errorNode, Diagnostics.Call_target_does_not_contain_any_signatures));
2140221419 }
2140321420 return resolveErrorCall(node);
2140421421 }
@@ -21476,31 +21493,45 @@ namespace ts {
2147621493 // If candidate is undefined, it means that no candidates had a suitable arity. In that case,
2147721494 // skip the checkApplicableSignature check.
2147821495 if (reportErrors) {
21496+ const errorNode = getCallErrorNode(node);
21497+
2147921498 if (candidateForArgumentError) {
2148021499 checkApplicableSignature(node, args, candidateForArgumentError, assignableRelation, CheckMode.Normal, /*reportErrors*/ true);
2148121500 }
2148221501 else if (candidateForArgumentArityError) {
21483- diagnostics.add(getArgumentArityError(node , [candidateForArgumentArityError], args));
21502+ diagnostics.add(getArgumentArityError(errorNode , [candidateForArgumentArityError], args));
2148421503 }
2148521504 else if (candidateForTypeArgumentError) {
2148621505 checkTypeArguments(candidateForTypeArgumentError, (node as CallExpression | TaggedTemplateExpression | JsxOpeningLikeElement).typeArguments!, /*reportErrors*/ true, fallbackError);
2148721506 }
2148821507 else {
2148921508 const signaturesWithCorrectTypeArgumentArity = filter(signatures, s => hasCorrectTypeArgumentArity(s, typeArguments));
2149021509 if (signaturesWithCorrectTypeArgumentArity.length === 0) {
21491- diagnostics.add(getTypeArgumentArityError(node , signatures, typeArguments!));
21510+ diagnostics.add(getTypeArgumentArityError(errorNode , signatures, typeArguments!));
2149221511 }
2149321512 else if (!isDecorator) {
21494- diagnostics.add(getArgumentArityError(node , signaturesWithCorrectTypeArgumentArity, args));
21513+ diagnostics.add(getArgumentArityError(errorNode , signaturesWithCorrectTypeArgumentArity, args));
2149521514 }
2149621515 else if (fallbackError) {
21497- diagnostics.add(createDiagnosticForNode(node , fallbackError));
21516+ diagnostics.add(createDiagnosticForNode(errorNode , fallbackError));
2149821517 }
2149921518 }
2150021519 }
2150121520
2150221521 return produceDiagnostics || !args ? resolveErrorCall(node) : getCandidateForOverloadFailure(node, candidates, args, !!candidatesOutArray);
2150321522
21523+ function getCallErrorNode(node: CallLikeExpression): Node {
21524+ if (isCallExpression(node)) {
21525+ if (isPropertyAccessExpression(node.expression)) {
21526+ return node.expression.name;
21527+ }
21528+ else {
21529+ return node.expression;
21530+ }
21531+ }
21532+ return node;
21533+ }
21534+
2150421535 function chooseOverload(candidates: Signature[], relation: Map<RelationComparisonResult>, signatureHelpTrailingComma = false) {
2150521536 candidateForArgumentError = undefined;
2150621537 candidateForArgumentArityError = undefined;
0 commit comments