@@ -4183,7 +4183,8 @@ namespace ts {
41834183 return {
41844184 accessibility: SymbolAccessibility.CannotBeNamed,
41854185 errorSymbolName: symbolToString(symbol, enclosingDeclaration, meaning),
4186- errorModuleName: symbolToString(symbolExternalModule)
4186+ errorModuleName: symbolToString(symbolExternalModule),
4187+ errorNode: isInJSFile(enclosingDeclaration) ? enclosingDeclaration : undefined,
41874188 };
41884189 }
41894190 }
@@ -4699,7 +4700,7 @@ namespace ts {
46994700
47004701 function createMappedTypeNodeFromType(type: MappedType) {
47014702 Debug.assert(!!(type.flags & TypeFlags.Object));
4702- const readonlyToken = type.declaration.readonlyToken ? <ReadonlyToken | PlusToken | MinusToken>factory.createToken(type.declaration.readonlyToken.kind) : undefined;
4703+ const readonlyToken = type.declaration.readonlyToken ? <ReadonlyKeyword | PlusToken | MinusToken>factory.createToken(type.declaration.readonlyToken.kind) : undefined;
47034704 const questionToken = type.declaration.questionToken ? <QuestionToken | PlusToken | MinusToken>factory.createToken(type.declaration.questionToken.kind) : undefined;
47044705 let appropriateConstraintTypeNode: TypeNode;
47054706 if (isMappedTypeWithKeyofConstraintDeclaration(type)) {
@@ -6183,7 +6184,7 @@ namespace ts {
61836184 tracker: {
61846185 ...oldcontext.tracker,
61856186 trackSymbol: (sym, decl, meaning) => {
6186- const accessibleResult = isSymbolAccessible(sym, decl, meaning, /*computeALiases */ false);
6187+ const accessibleResult = isSymbolAccessible(sym, decl, meaning, /*computeAliases */ false);
61876188 if (accessibleResult.accessibility === SymbolAccessibility.Accessible) {
61886189 // Lookup the root symbol of the chain of refs we'll use to access it and serialize it
61896190 const chain = lookupSymbolChainWorker(sym, context, meaning);
@@ -6625,16 +6626,17 @@ namespace ts {
66256626 function addResult(node: Statement, additionalModifierFlags: ModifierFlags) {
66266627 if (canHaveModifiers(node)) {
66276628 let newModifierFlags: ModifierFlags = ModifierFlags.None;
6629+ const enclosingDeclaration = context.enclosingDeclaration &&
6630+ (isJSDocTypeAlias(context.enclosingDeclaration) ? getSourceFileOfNode(context.enclosingDeclaration) : context.enclosingDeclaration);
66286631 if (additionalModifierFlags & ModifierFlags.Export &&
6629- context.enclosingDeclaration &&
6630- (isExportingScope(context.enclosingDeclaration) || isModuleDeclaration(context.enclosingDeclaration)) &&
6632+ enclosingDeclaration && (isExportingScope(enclosingDeclaration) || isModuleDeclaration(enclosingDeclaration)) &&
66316633 canHaveExportModifier(node)
66326634 ) {
66336635 // Classes, namespaces, variables, functions, interfaces, and types should all be `export`ed in a module context if not private
66346636 newModifierFlags |= ModifierFlags.Export;
66356637 }
66366638 if (addingDeclare && !(newModifierFlags & ModifierFlags.Export) &&
6637- (!context. enclosingDeclaration || !(context. enclosingDeclaration.flags & NodeFlags.Ambient)) &&
6639+ (!enclosingDeclaration || !(enclosingDeclaration.flags & NodeFlags.Ambient)) &&
66386640 (isEnumDeclaration(node) || isVariableStatement(node) || isFunctionDeclaration(node) || isClassDeclaration(node) || isModuleDeclaration(node))) {
66396641 // Classes, namespaces, variables, enums, and functions all need `declare` modifiers to be valid in a declaration file top-level scope
66406642 newModifierFlags |= ModifierFlags.Ambient;
@@ -6657,6 +6659,8 @@ namespace ts {
66576659 const commentText = jsdocAliasDecl ? jsdocAliasDecl.comment || jsdocAliasDecl.parent.comment : undefined;
66586660 const oldFlags = context.flags;
66596661 context.flags |= NodeBuilderFlags.InTypeAlias;
6662+ const oldEnclosingDecl = context.enclosingDeclaration;
6663+ context.enclosingDeclaration = jsdocAliasDecl;
66606664 const typeNode = jsdocAliasDecl && jsdocAliasDecl.typeExpression
66616665 && isJSDocTypeExpression(jsdocAliasDecl.typeExpression)
66626666 && serializeExistingTypeNode(context, jsdocAliasDecl.typeExpression.type, includePrivateSymbol, bundled)
@@ -6666,6 +6670,7 @@ namespace ts {
66666670 !commentText ? [] : [{ kind: SyntaxKind.MultiLineCommentTrivia, text: "*\n * " + commentText.replace(/\n/g, "\n * ") + "\n ", pos: -1, end: -1, hasTrailingNewLine: true }]
66676671 ), modifierFlags);
66686672 context.flags = oldFlags;
6673+ context.enclosingDeclaration = oldEnclosingDecl;
66696674 }
66706675
66716676 function serializeInterface(symbol: Symbol, symbolName: string, modifierFlags: ModifierFlags) {
@@ -14642,6 +14647,7 @@ namespace ts {
1464214647 // types of the form 'A extends B ? X : C extends D ? Y : E extends F ? Z : ...' as a single construct for
1464314648 // purposes of resolution. This means such types aren't subject to the instatiation depth limiter.
1464414649 while (true) {
14650+ const isUnwrapped = isTypicalNondistributiveConditional(root);
1464514651 const checkType = instantiateType(unwrapNondistributiveConditionalTuple(root, root.checkType), mapper);
1464614652 const checkTypeInstantiable = isGenericObjectType(checkType) || isGenericIndexType(checkType);
1464714653 const extendsType = instantiateType(unwrapNondistributiveConditionalTuple(root, root.extendsType), mapper);
@@ -14667,9 +14673,9 @@ namespace ts {
1466714673 // types with type parameters mapped to the wildcard type, the most permissive instantiations
1466814674 // possible (the wildcard type is assignable to and from all types). If those are not related,
1466914675 // then no instantiations will be and we can just return the false branch type.
14670- if (!(inferredExtendsType.flags & TypeFlags.AnyOrUnknown) && ((checkType.flags & TypeFlags.Any && root.isDistributive ) || !isTypeAssignableTo(getPermissiveInstantiation(checkType), getPermissiveInstantiation(inferredExtendsType)))) {
14676+ if (!(inferredExtendsType.flags & TypeFlags.AnyOrUnknown) && ((checkType.flags & TypeFlags.Any && !isUnwrapped ) || !isTypeAssignableTo(getPermissiveInstantiation(checkType), getPermissiveInstantiation(inferredExtendsType)))) {
1467114677 // Return union of trueType and falseType for 'any' since it matches anything
14672- if (checkType.flags & TypeFlags.Any && root.isDistributive ) {
14678+ if (checkType.flags & TypeFlags.Any && !isUnwrapped ) {
1467314679 (extraTypes || (extraTypes = [])).push(instantiateType(getTypeFromTypeNode(root.node.trueType), combinedMapper || mapper));
1467414680 }
1467514681 // If falseType is an immediately nested conditional type that isn't distributive or has an
@@ -21284,8 +21290,12 @@ namespace ts {
2128421290 case SyntaxKind.PropertyAccessExpression:
2128521291 case SyntaxKind.ElementAccessExpression:
2128621292 return isAccessExpression(target) &&
21287- getAccessedPropertyName(<AccessExpression>source) === getAccessedPropertyName(target) &&
21288- isMatchingReference((<AccessExpression>source).expression, target.expression);
21293+ getAccessedPropertyName(source as AccessExpression) === getAccessedPropertyName(target) &&
21294+ isMatchingReference((source as AccessExpression).expression, target.expression);
21295+ case SyntaxKind.QualifiedName:
21296+ return isAccessExpression(target) &&
21297+ (source as QualifiedName).right.escapedText === getAccessedPropertyName(target) &&
21298+ isMatchingReference((source as QualifiedName).left, target.expression);
2128921299 case SyntaxKind.BinaryExpression:
2129021300 return (isBinaryExpression(source) && source.operatorToken.kind === SyntaxKind.CommaToken && isMatchingReference(source.right, target));
2129121301 }
@@ -22631,13 +22641,13 @@ namespace ts {
2263122641 if (propName === undefined) {
2263222642 return type;
2263322643 }
22634- const includesUndefined = strictNullChecks && maybeTypeOfKind(type, TypeFlags.Undefined );
22635- const removeOptional = includesUndefined && isOptionalChain(access);
22636- let propType = getTypeOfPropertyOfType(removeOptional ? getTypeWithFacts(type, TypeFacts.NEUndefined ) : type, propName);
22644+ const includesNullable = strictNullChecks && maybeTypeOfKind(type, TypeFlags.Nullable );
22645+ const removeNullable = includesNullable && isOptionalChain(access);
22646+ let propType = getTypeOfPropertyOfType(removeNullable ? getTypeWithFacts(type, TypeFacts.NEUndefinedOrNull ) : type, propName);
2263722647 if (!propType) {
2263822648 return type;
2263922649 }
22640- propType = removeOptional ? getOptionalType(propType) : propType;
22650+ propType = removeNullable ? getOptionalType(propType) : propType;
2264122651 const narrowedPropType = narrowType(propType);
2264222652 return filterType(type, t => {
2264322653 const discriminantType = getTypeOfPropertyOrIndexSignature(t, propName);
@@ -24752,6 +24762,8 @@ namespace ts {
2475224762 const tag = isInJSFile(parent) ? getJSDocTypeTag(parent) : undefined;
2475324763 return tag ? getTypeFromTypeNode(tag.typeExpression.type) : getContextualType(<ParenthesizedExpression>parent, contextFlags);
2475424764 }
24765+ case SyntaxKind.NonNullExpression:
24766+ return getContextualType(parent as NonNullExpression, contextFlags);
2475524767 case SyntaxKind.JsxExpression:
2475624768 return getContextualTypeForJsxExpression(<JsxExpression>parent);
2475724769 case SyntaxKind.JsxAttribute:
@@ -26414,8 +26426,7 @@ namespace ts {
2641426426 // assignment target, and the referenced property was declared as a variable, property,
2641526427 // accessor, or optional method.
2641626428 const assignmentKind = getAssignmentTargetKind(node);
26417- if (!isAccessExpression(node) ||
26418- assignmentKind === AssignmentKind.Definite ||
26429+ if (assignmentKind === AssignmentKind.Definite ||
2641926430 prop && !(prop.flags & (SymbolFlags.Variable | SymbolFlags.Property | SymbolFlags.Accessor)) && !(prop.flags & SymbolFlags.Method && propType.flags & TypeFlags.Union)) {
2642026431 return propType;
2642126432 }
@@ -26427,7 +26438,7 @@ namespace ts {
2642726438 // and if we are in a constructor of the same class as the property declaration, assume that
2642826439 // the property is uninitialized at the top of the control flow.
2642926440 let assumeUninitialized = false;
26430- if (strictNullChecks && strictPropertyInitialization && node.expression.kind === SyntaxKind.ThisKeyword) {
26441+ if (strictNullChecks && strictPropertyInitialization && isAccessExpression(node) && node.expression.kind === SyntaxKind.ThisKeyword) {
2643126442 const declaration = prop && prop.valueDeclaration;
2643226443 if (declaration && isInstancePropertyWithoutInitializer(declaration)) {
2643326444 const flowContainer = getControlFlowContainer(node);
0 commit comments