Microsoft/TypeScript
1
0
Fork 0
mirror of https://github.com/microsoft/TypeScript.git synced 2025-11-18 17:21:48 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'master' into usePrependToSkipBuild

Browse Source
This commit is contained in:
Sheetal Nandi
2019-02-07 10:39:41 -08:00
parent 3a28fb0786 8e5dcfbde5
commit ab7d65e01f
120 changed files with 3960 additions and 2022 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/compiler/binder.ts
+41 -37
View File
@@ -1120,11 +1120,15 @@ namespace ts {
// We add the nodes within the `try` block to the `finally`'s antecedents if there's no catch block
// (If there is a `catch` block, it will have all these antecedents instead, and the `finally` will
// have the end of the `try` block and the end of the `catch` block)
let preFinallyPrior = preTryFlow;
if (!node.catchClause) {
if (tryPriors.length) {
const preFinallyFlow = createBranchLabel();
addAntecedent(preFinallyFlow, preTryFlow);
for (const p of tryPriors) {
addAntecedent(preFinallyLabel, p);
addAntecedent(preFinallyFlow, p);
}
preFinallyPrior = finishFlowLabel(preFinallyFlow);
}
}
@@ -1156,7 +1160,7 @@ namespace ts {
//
// extra edges that we inject allows to control this behavior
// if when walking the flow we step on post-finally edge - we can mark matching pre-finally edge as locked so it will be skipped.
const preFinallyFlow: PreFinallyFlow = { flags: FlowFlags.PreFinally, antecedent: preTryFlow, lock: {} };
const preFinallyFlow: PreFinallyFlow = { flags: FlowFlags.PreFinally, antecedent: preFinallyPrior, lock: {} };
addAntecedent(preFinallyLabel, preFinallyFlow);
currentFlow = finishFlowLabel(preFinallyLabel);
@@ -3137,8 +3141,8 @@ namespace ts {
if (operatorTokenKind === SyntaxKind.EqualsToken && leftKind === SyntaxKind.ObjectLiteralExpression) {
// Destructuring object assignments with are ES2015 syntax
// and possibly ESNext if they contain rest
transformFlags |= TransformFlags.AssertESNext | TransformFlags.AssertES2015 | TransformFlags.AssertDestructuringAssignment;
// and possibly ES2018 if they contain rest
transformFlags |= TransformFlags.AssertES2018 | TransformFlags.AssertES2015 | TransformFlags.AssertDestructuringAssignment;
}
else if (operatorTokenKind === SyntaxKind.EqualsToken && leftKind === SyntaxKind.ArrayLiteralExpression) {
// Destructuring assignments are ES2015 syntax.
@@ -3174,9 +3178,9 @@ namespace ts {
transformFlags |= TransformFlags.AssertTypeScript | TransformFlags.ContainsTypeScriptClassSyntax;
}
// parameters with object rest destructuring are ES Next syntax
// parameters with object rest destructuring are ES2018 syntax
if (subtreeFlags & TransformFlags.ContainsObjectRestOrSpread) {
transformFlags |= TransformFlags.AssertESNext;
transformFlags |= TransformFlags.AssertES2018;
}
// If a parameter has an initializer, a binding pattern or a dotDotDot token, then
@@ -3326,9 +3330,9 @@ namespace ts {
transformFlags |= TransformFlags.AssertTypeScript;
}
// function declarations with object rest destructuring are ES Next syntax
// function declarations with object rest destructuring are ES2018 syntax
if (subtreeFlags & TransformFlags.ContainsObjectRestOrSpread) {
transformFlags |= TransformFlags.AssertESNext;
transformFlags |= TransformFlags.AssertES2018;
}
node.transformFlags = transformFlags | TransformFlags.HasComputedFlags;
@@ -3350,14 +3354,14 @@ namespace ts {
transformFlags |= TransformFlags.AssertTypeScript;
}
// function declarations with object rest destructuring are ES Next syntax
// function declarations with object rest destructuring are ES2018 syntax
if (subtreeFlags & TransformFlags.ContainsObjectRestOrSpread) {
transformFlags |= TransformFlags.AssertESNext;
transformFlags |= TransformFlags.AssertES2018;
}
// An async method declaration is ES2017 syntax.
if (hasModifier(node, ModifierFlags.Async)) {
transformFlags |= node.asteriskToken ? TransformFlags.AssertESNext : TransformFlags.AssertES2017;
transformFlags |= node.asteriskToken ? TransformFlags.AssertES2018 : TransformFlags.AssertES2017;
}
if (node.asteriskToken) {
@@ -3381,9 +3385,9 @@ namespace ts {
transformFlags |= TransformFlags.AssertTypeScript;
}
// function declarations with object rest destructuring are ES Next syntax
// function declarations with object rest destructuring are ES2018 syntax
if (subtreeFlags & TransformFlags.ContainsObjectRestOrSpread) {
transformFlags |= TransformFlags.AssertESNext;
transformFlags |= TransformFlags.AssertES2018;
}
node.transformFlags = transformFlags | TransformFlags.HasComputedFlags;
@@ -3427,12 +3431,12 @@ namespace ts {
// An async function declaration is ES2017 syntax.
if (modifierFlags & ModifierFlags.Async) {
transformFlags |= node.asteriskToken ? TransformFlags.AssertESNext : TransformFlags.AssertES2017;
transformFlags |= node.asteriskToken ? TransformFlags.AssertES2018 : TransformFlags.AssertES2017;
}
// function declarations with object rest destructuring are ES Next syntax
// function declarations with object rest destructuring are ES2018 syntax
if (subtreeFlags & TransformFlags.ContainsObjectRestOrSpread) {
transformFlags |= TransformFlags.AssertESNext;
transformFlags |= TransformFlags.AssertES2018;
}
// If a FunctionDeclaration's subtree has marked the container as needing to capture the
@@ -3469,12 +3473,12 @@ namespace ts {
// An async function expression is ES2017 syntax.
if (hasModifier(node, ModifierFlags.Async)) {
transformFlags |= node.asteriskToken ? TransformFlags.AssertESNext : TransformFlags.AssertES2017;
transformFlags |= node.asteriskToken ? TransformFlags.AssertES2018 : TransformFlags.AssertES2017;
}
// function expressions with object rest destructuring are ES Next syntax
// function expressions with object rest destructuring are ES2018 syntax
if (subtreeFlags & TransformFlags.ContainsObjectRestOrSpread) {
transformFlags |= TransformFlags.AssertESNext;
transformFlags |= TransformFlags.AssertES2018;
}
@@ -3513,9 +3517,9 @@ namespace ts {
transformFlags |= TransformFlags.AssertES2017;
}
// arrow functions with object rest destructuring are ES Next syntax
// arrow functions with object rest destructuring are ES2018 syntax
if (subtreeFlags & TransformFlags.ContainsObjectRestOrSpread) {
transformFlags |= TransformFlags.AssertESNext;
transformFlags |= TransformFlags.AssertES2018;
}
// If an ArrowFunction contains a lexical this, its container must capture the lexical this.
@@ -3535,8 +3539,8 @@ namespace ts {
if (transformFlags & TransformFlags.Super) {
transformFlags ^= TransformFlags.Super;
// super inside of an async function requires hoisting the super access (ES2017).
// same for super inside of an async generator, which is ESNext.
transformFlags |= TransformFlags.ContainsSuper | TransformFlags.ContainsES2017 | TransformFlags.ContainsESNext;
// same for super inside of an async generator, which is ES2018.
transformFlags |= TransformFlags.ContainsSuper | TransformFlags.ContainsES2017 | TransformFlags.ContainsES2018;
}
node.transformFlags = transformFlags | TransformFlags.HasComputedFlags;
@@ -3553,8 +3557,8 @@ namespace ts {
if (expressionFlags & TransformFlags.Super) {
transformFlags &= ~TransformFlags.Super;
// super inside of an async function requires hoisting the super access (ES2017).
// same for super inside of an async generator, which is ESNext.
transformFlags |= TransformFlags.ContainsSuper | TransformFlags.ContainsES2017 | TransformFlags.ContainsESNext;
// same for super inside of an async generator, which is ES2018.
transformFlags |= TransformFlags.ContainsSuper | TransformFlags.ContainsES2017 | TransformFlags.ContainsES2018;
}
node.transformFlags = transformFlags | TransformFlags.HasComputedFlags;
@@ -3565,9 +3569,9 @@ namespace ts {
let transformFlags = subtreeFlags;
transformFlags |= TransformFlags.AssertES2015 | TransformFlags.ContainsBindingPattern;
// A VariableDeclaration containing ObjectRest is ESNext syntax
// A VariableDeclaration containing ObjectRest is ES2018 syntax
if (subtreeFlags & TransformFlags.ContainsObjectRestOrSpread) {
transformFlags |= TransformFlags.AssertESNext;
transformFlags |= TransformFlags.AssertES2018;
}
// Type annotations are TypeScript syntax.
@@ -3674,8 +3678,8 @@ namespace ts {
switch (kind) {
case SyntaxKind.AsyncKeyword:
case SyntaxKind.AwaitExpression:
// async/await is ES2017 syntax, but may be ESNext syntax (for async generators)
transformFlags |= TransformFlags.AssertESNext | TransformFlags.AssertES2017;
// async/await is ES2017 syntax, but may be ES2018 syntax (for async generators)
transformFlags |= TransformFlags.AssertES2018 | TransformFlags.AssertES2017;
break;
case SyntaxKind.TypeAssertionExpression:
@@ -3747,7 +3751,7 @@ namespace ts {
case SyntaxKind.ForOfStatement:
// This node is either ES2015 syntax or ES2017 syntax (if it is a for-await-of).
if ((<ForOfStatement>node).awaitModifier) {
transformFlags |= TransformFlags.AssertESNext;
transformFlags |= TransformFlags.AssertES2018;
}
transformFlags |= TransformFlags.AssertES2015;
break;
@@ -3755,7 +3759,7 @@ namespace ts {
case SyntaxKind.YieldExpression:
// This node is either ES2015 syntax (in a generator) or ES2017 syntax (in an async
// generator).
transformFlags |= TransformFlags.AssertESNext | TransformFlags.AssertES2015 | TransformFlags.ContainsYield;
transformFlags |= TransformFlags.AssertES2018 | TransformFlags.AssertES2015 | TransformFlags.ContainsYield;
break;
case SyntaxKind.AnyKeyword:
@@ -3824,7 +3828,7 @@ namespace ts {
break;
case SyntaxKind.SpreadAssignment:
transformFlags |= TransformFlags.AssertESNext | TransformFlags.ContainsObjectRestOrSpread;
transformFlags |= TransformFlags.AssertES2018 | TransformFlags.ContainsObjectRestOrSpread;
break;
case SyntaxKind.SuperKeyword:
@@ -3841,7 +3845,7 @@ namespace ts {
case SyntaxKind.ObjectBindingPattern:
transformFlags |= TransformFlags.AssertES2015 | TransformFlags.ContainsBindingPattern;
if (subtreeFlags & TransformFlags.ContainsRestOrSpread) {
transformFlags |= TransformFlags.AssertESNext | TransformFlags.ContainsObjectRestOrSpread;
transformFlags |= TransformFlags.AssertES2018 | TransformFlags.ContainsObjectRestOrSpread;
}
excludeFlags = TransformFlags.BindingPatternExcludes;
break;
@@ -3879,8 +3883,8 @@ namespace ts {
if (subtreeFlags & TransformFlags.ContainsObjectRestOrSpread) {
// If an ObjectLiteralExpression contains a spread element, then it
// is an ES next node.
transformFlags |= TransformFlags.AssertESNext;
// is an ES2018 node.
transformFlags |= TransformFlags.AssertES2018;
}
break;
@@ -3915,8 +3919,8 @@ namespace ts {
break;
case SyntaxKind.ReturnStatement:
// Return statements may require an `await` in ESNext.
transformFlags |= TransformFlags.ContainsHoistedDeclarationOrCompletion | TransformFlags.AssertESNext;
// Return statements may require an `await` in ES2018.
transformFlags |= TransformFlags.ContainsHoistedDeclarationOrCompletion | TransformFlags.AssertES2018;
break;
case SyntaxKind.ContinueStatement:
src/compiler/checker.ts
+78 -37
View File
@@ -1716,7 +1716,7 @@ namespace ts {
}
const symbol = resolveSymbol(resolveName(errorLocation, name, SymbolFlags.Type & ~SymbolFlags.Value, /*nameNotFoundMessage*/undefined, /*nameArg*/ undefined, /*isUse*/ false));
if (symbol && !(symbol.flags & SymbolFlags.NamespaceModule)) {
const message = (name === "Promise" || name === "Symbol")
const message = isES2015OrLaterConstructorName(name)
? Diagnostics._0_only_refers_to_a_type_but_is_being_used_as_a_value_here_Do_you_need_to_change_your_target_library_Try_changing_the_lib_compiler_option_to_es2015_or_later
: Diagnostics._0_only_refers_to_a_type_but_is_being_used_as_a_value_here;
error(errorLocation, message, unescapeLeadingUnderscores(name));
@@ -1726,6 +1726,19 @@ namespace ts {
return false;
}
function isES2015OrLaterConstructorName(n: __String) {
switch (n) {
case "Promise":
case "Symbol":
case "Map":
case "WeakMap":
case "Set":
case "WeakSet":
return true;
}
return false;
}
function checkAndReportErrorForUsingNamespaceModuleAsValue(errorLocation: Node, name: __String, meaning: SymbolFlags): boolean {
if (meaning & (SymbolFlags.Value & ~SymbolFlags.NamespaceModule & ~SymbolFlags.Type)) {
const symbol = resolveSymbol(resolveName(errorLocation, name, SymbolFlags.NamespaceModule & ~SymbolFlags.Value, /*nameNotFoundMessage*/undefined, /*nameArg*/ undefined, /*isUse*/ false));
@@ -10841,7 +10854,7 @@ namespace ts {
function getHomomorphicTypeVariable(type: MappedType) {
const constraintType = getConstraintTypeFromMappedType(type);
if (constraintType.flags & TypeFlags.Index) {
const typeVariable = (<IndexType>constraintType).type;
const typeVariable = getActualTypeVariable((<IndexType>constraintType).type);
if (typeVariable.flags & TypeFlags.TypeParameter) {
return <TypeParameter>typeVariable;
}
@@ -10864,26 +10877,15 @@ namespace ts {
if (typeVariable) {
const mappedTypeVariable = instantiateType(typeVariable, mapper);
if (typeVariable !== mappedTypeVariable) {
// If we are already in the process of creating an instantiation of this mapped type,
// return the error type. This situation only arises if we are instantiating the mapped
// type for an array or tuple type, as we then need to eagerly resolve the (possibly
// circular) element type(s).
if (type.instantiating) {
return errorType;
}
type.instantiating = true;
const modifiers = getMappedTypeModifiers(type);
const result = mapType(mappedTypeVariable, t => {
if (t.flags & (TypeFlags.AnyOrUnknown | TypeFlags.InstantiableNonPrimitive | TypeFlags.Object | TypeFlags.Intersection) && t !== wildcardType) {
return mapType(mappedTypeVariable, t => {
if (t.flags & (TypeFlags.AnyOrUnknown | TypeFlags.InstantiableNonPrimitive | TypeFlags.Object | TypeFlags.Intersection) && t !== wildcardType && t !== errorType) {
const replacementMapper = createReplacementMapper(typeVariable, t, mapper);
return isArrayType(t) ? createArrayType(instantiateMappedTypeTemplate(type, numberType, /*isOptional*/ true, replacementMapper), getModifiedReadonlyState(isReadonlyArrayType(t), modifiers)) :
return isArrayType(t) ? instantiateMappedArrayType(t, type, replacementMapper) :
isTupleType(t) ? instantiateMappedTupleType(t, type, replacementMapper) :
instantiateAnonymousType(type, replacementMapper);
}
return t;
});
type.instantiating = false;
return result;
}
}
return instantiateAnonymousType(type, mapper);
@@ -10893,6 +10895,12 @@ namespace ts {
return modifiers & MappedTypeModifiers.IncludeReadonly ? true : modifiers & MappedTypeModifiers.ExcludeReadonly ? false : state;
}
function instantiateMappedArrayType(arrayType: Type, mappedType: MappedType, mapper: TypeMapper) {
const elementType = instantiateMappedTypeTemplate(mappedType, numberType, /*isOptional*/ true, mapper);
return elementType === errorType ? errorType :
createArrayType(elementType, getModifiedReadonlyState(isReadonlyArrayType(arrayType), getMappedTypeModifiers(mappedType)));
}
function instantiateMappedTupleType(tupleType: TupleTypeReference, mappedType: MappedType, mapper: TypeMapper) {
const minLength = tupleType.target.minLength;
const elementTypes = map(tupleType.typeArguments || emptyArray, (_, i) =>
@@ -10902,7 +10910,8 @@ namespace ts {
modifiers & MappedTypeModifiers.ExcludeOptional ? getTypeReferenceArity(tupleType) - (tupleType.target.hasRestElement ? 1 : 0) :
minLength;
const newReadonly = getModifiedReadonlyState(tupleType.target.readonly, modifiers);
return createTupleType(elementTypes, newMinLength, tupleType.target.hasRestElement, newReadonly, tupleType.target.associatedNames);
return contains(elementTypes, errorType) ? errorType :
createTupleType(elementTypes, newMinLength, tupleType.target.hasRestElement, newReadonly, tupleType.target.associatedNames);
}
function instantiateMappedTypeTemplate(type: MappedType, key: Type, isOptional: boolean, mapper: TypeMapper) {
@@ -16151,13 +16160,37 @@ namespace ts {
}
function narrowTypeBySwitchOnDiscriminant(type: Type, switchStatement: SwitchStatement, clauseStart: number, clauseEnd: number) {
// We only narrow if all case expressions specify values with unit types
// We only narrow if all case expressions specify
// values with unit types, except for the case where
// `type` is unknown. In this instance we map object
// types to the nonPrimitive type and narrow with that.
const switchTypes = getSwitchClauseTypes(switchStatement);
if (!switchTypes.length) {
return type;
}
const clauseTypes = switchTypes.slice(clauseStart, clauseEnd);
const hasDefaultClause = clauseStart === clauseEnd || contains(clauseTypes, neverType);
if ((type.flags & TypeFlags.Unknown) && !hasDefaultClause) {
let groundClauseTypes: Type[] | undefined;
for (let i = 0; i < clauseTypes.length; i += 1) {
const t = clauseTypes[i];
if (t.flags & (TypeFlags.Primitive | TypeFlags.NonPrimitive)) {
if (groundClauseTypes !== undefined) {
groundClauseTypes.push(t);
}
}
else if (t.flags & TypeFlags.Object) {
if (groundClauseTypes === undefined) {
groundClauseTypes = clauseTypes.slice(0, i);
}
groundClauseTypes.push(nonPrimitiveType);
}
else {
return type;
}
}
return getUnionType(groundClauseTypes === undefined ? clauseTypes : groundClauseTypes);
}
const discriminantType = getUnionType(clauseTypes);
const caseType =
discriminantType.flags & TypeFlags.Never ? neverType :
@@ -23265,24 +23298,36 @@ namespace ts {
const uninstantiatedType = checkExpressionWorker(node, checkMode, forceTuple);
const type = instantiateTypeWithSingleGenericCallSignature(node, uninstantiatedType, checkMode);
if (isConstEnumObjectType(type)) {
// enum object type for const enums are only permitted in:
// - 'left' in property access
// - 'object' in indexed access
// - target in rhs of import statement
const ok =
(node.parent.kind === SyntaxKind.PropertyAccessExpression && (<PropertyAccessExpression>node.parent).expression === node) ||
(node.parent.kind === SyntaxKind.ElementAccessExpression && (<ElementAccessExpression>node.parent).expression === node) ||
((node.kind === SyntaxKind.Identifier || node.kind === SyntaxKind.QualifiedName) && isInRightSideOfImportOrExportAssignment(<Identifier>node) ||
(node.parent.kind === SyntaxKind.TypeQuery && (<TypeQueryNode>node.parent).exprName === node));
if (!ok) {
error(node, Diagnostics.const_enums_can_only_be_used_in_property_or_index_access_expressions_or_the_right_hand_side_of_an_import_declaration_or_export_assignment_or_type_query);
}
checkConstEnumAccess(node, type);
}
currentNode = saveCurrentNode;
return type;
}
function checkConstEnumAccess(node: Expression | QualifiedName, type: Type) {
// enum object type for const enums are only permitted in:
// - 'left' in property access
// - 'object' in indexed access
// - target in rhs of import statement
const ok =
(node.parent.kind === SyntaxKind.PropertyAccessExpression && (<PropertyAccessExpression>node.parent).expression === node) ||
(node.parent.kind === SyntaxKind.ElementAccessExpression && (<ElementAccessExpression>node.parent).expression === node) ||
((node.kind === SyntaxKind.Identifier || node.kind === SyntaxKind.QualifiedName) && isInRightSideOfImportOrExportAssignment(<Identifier>node) ||
(node.parent.kind === SyntaxKind.TypeQuery && (<TypeQueryNode>node.parent).exprName === node));
if (!ok) {
error(node, Diagnostics.const_enums_can_only_be_used_in_property_or_index_access_expressions_or_the_right_hand_side_of_an_import_declaration_or_export_assignment_or_type_query);
}
if (compilerOptions.isolatedModules) {
Debug.assert(!!(type.symbol.flags & SymbolFlags.ConstEnum));
const constEnumDeclaration = type.symbol.valueDeclaration as EnumDeclaration;
if (constEnumDeclaration.flags & NodeFlags.Ambient) {
error(node, Diagnostics.Cannot_access_ambient_const_enums_when_the_isolatedModules_flag_is_provided);
}
}
}
function checkParenthesizedExpression(node: ParenthesizedExpression, checkMode?: CheckMode): Type {
const tag = isInJSFile(node) ? getJSDocTypeTag(node) : undefined;
if (tag) {
@@ -27225,7 +27270,7 @@ namespace ts {
reference.expression.parent = reference;
reference.parent = constructor;
reference.flowNode = constructor.returnFlowNode;
const flowType = getFlowTypeOfReference(reference, getOptionalType(propType));
const flowType = getFlowTypeOfReference(reference, propType, getOptionalType(propType));
return !(getFalsyFlags(flowType) & TypeFlags.Undefined);
}
@@ -27460,11 +27505,6 @@ namespace ts {
computeEnumMemberValues(node);
const enumIsConst = isEnumConst(node);
if (compilerOptions.isolatedModules && enumIsConst && node.flags & NodeFlags.Ambient) {
error(node.name, Diagnostics.Ambient_const_enums_are_not_allowed_when_the_isolatedModules_flag_is_provided);
}
// Spec 2014 - Section 9.3:
// It isn't possible for one enum declaration to continue the automatic numbering sequence of another,
// and when an enum type has multiple declarations, only one declaration is permitted to omit a value
@@ -27475,6 +27515,7 @@ namespace ts {
const firstDeclaration = getDeclarationOfKind(enumSymbol, node.kind);
if (node === firstDeclaration) {
if (enumSymbol.declarations.length > 1) {
const enumIsConst = isEnumConst(node);
// check that const is placed\omitted on all enum declarations
forEach(enumSymbol.declarations, decl => {
if (isEnumDeclaration(decl) && isEnumConst(decl) !== enumIsConst) {
src/compiler/core.ts
+1 -1
View File
@@ -1652,7 +1652,7 @@ namespace ts {
}
export function assertNever(member: never, message = "Illegal value:", stackCrawlMark?: AnyFunction): never {
const detail = "kind" in member && "pos" in member ? "SyntaxKind: " + showSyntaxKind(member as Node) : JSON.stringify(member);
const detail = typeof member === "object" && "kind" in member && "pos" in member ? "SyntaxKind: " + showSyntaxKind(member as Node) : JSON.stringify(member);
return fail(`${message} ${detail}`, stackCrawlMark || assertNever);
}
src/compiler/diagnosticMessages.json
+4 -4
View File
@@ -659,10 +659,6 @@
"category": "Error",
"code": 1208
},
"Ambient const enums are not allowed when the '--isolatedModules' flag is provided.": {
"category": "Error",
"code": 1209
},
"Invalid use of '{0}'. Class definitions are automatically in strict mode.": {
"category": "Error",
"code": 1210
@@ -2581,6 +2577,10 @@
"category": "Error",
"code": 2747
},
"Cannot access ambient const enums when the '--isolatedModules' flag is provided.": {
"category": "Error",
"code": 2748
},
"Import declaration '{0}' is using private name '{1}'.": {
"category": "Error",
src/compiler/factory.ts
+5 -5
View File
@@ -2629,7 +2629,7 @@ namespace ts {
return node;
}
let allUnscopedEmitHelpers: ReadonlyMap<UnscopedEmitHelpers> | undefined;
let allUnscopedEmitHelpers: ReadonlyMap<UnscopedEmitHelper> | undefined;
function getAllUnscopedEmitHelpers() {
return allUnscopedEmitHelpers || (allUnscopedEmitHelpers = arrayToMap([
valuesHelper,
@@ -2668,7 +2668,7 @@ namespace ts {
export function createUnparsedSourceFile(textOrInputFiles: string | InputFiles, mapPathOrType?: string, mapText?: string): UnparsedSource {
const node = createUnparsedSource();
let prologues: UnparsedPrologue[] | undefined;
let helpers: UnscopedEmitHelpers[] | undefined;
let helpers: UnscopedEmitHelper[] | undefined;
let referencedFiles: FileReference[] | undefined;
let typeReferenceDirectives: string[] | undefined;
let libReferenceDirectives: FileReference[] | undefined;
@@ -3613,7 +3613,7 @@ namespace ts {
return setEmitFlags(createIdentifier(name), EmitFlags.HelperName | EmitFlags.AdviseOnEmitNode);
}
export const valuesHelper: UnscopedEmitHelpers = {
export const valuesHelper: UnscopedEmitHelper = {
name: "typescript:values",
scoped: false,
text: `
@@ -3641,7 +3641,7 @@ namespace ts {
);
}
export const readHelper: UnscopedEmitHelpers = {
export const readHelper: UnscopedEmitHelper = {
name: "typescript:read",
scoped: false,
text: `
@@ -3677,7 +3677,7 @@ namespace ts {
);
}
export const spreadHelper: UnscopedEmitHelpers = {
export const spreadHelper: UnscopedEmitHelper = {
name: "typescript:spread",
scoped: false,
text: `
src/compiler/transformer.ts
+4
View File
@@ -42,6 +42,10 @@ namespace ts {
transformers.push(transformESNext);
}
if (languageVersion < ScriptTarget.ES2018) {
transformers.push(transformES2018);
}
if (languageVersion < ScriptTarget.ES2017) {
transformers.push(transformES2017);
}
src/compiler/transformers/destructuring.ts
+1 -1
View File
@@ -512,7 +512,7 @@ namespace ts {
return name;
}
export const restHelper: UnscopedEmitHelpers = {
export const restHelper: UnscopedEmitHelper = {
name: "typescript:rest",
scoped: false,
text: `
src/compiler/transformers/es2015.ts
+2 -2
View File
@@ -4383,7 +4383,7 @@ namespace ts {
);
}
export const extendsHelper: UnscopedEmitHelpers = {
export const extendsHelper: UnscopedEmitHelper = {
name: "typescript:extends",
scoped: false,
priority: 0,
@@ -4404,7 +4404,7 @@ namespace ts {
})();`
};
export const templateObjectHelper: UnscopedEmitHelpers = {
export const templateObjectHelper: UnscopedEmitHelper = {
name: "typescript:makeTemplateObject",
scoped: false,
priority: 0,
src/compiler/transformers/es2017.ts
+1 -1
View File
@@ -750,7 +750,7 @@ namespace ts {
NodeFlags.Const));
}
export const awaiterHelper: UnscopedEmitHelpers = {
export const awaiterHelper: UnscopedEmitHelper = {
name: "typescript:awaiter",
scoped: false,
priority: 5,
src/compiler/transformers/es2018.ts
+1046
View File
File diff suppressed because it is too large Load Diff
src/compiler/transformers/esnext.ts
+1 -1023
View File
File diff suppressed because it is too large Load Diff
src/compiler/transformers/generators.ts
+1 -1
View File
@@ -3240,7 +3240,7 @@ namespace ts {
// entering a finally block.
//
// For examples of how these are used, see the comments in ./transformers/generators.ts
export const generatorHelper: UnscopedEmitHelpers = {
export const generatorHelper: UnscopedEmitHelper = {
name: "typescript:generator",
scoped: false,
priority: 6,
src/compiler/transformers/module/module.ts
+2 -2
View File
@@ -1806,7 +1806,7 @@ namespace ts {
};
// emit helper for `import * as Name from "foo"`
export const importStarHelper: UnscopedEmitHelpers = {
export const importStarHelper: UnscopedEmitHelper = {
name: "typescript:commonjsimportstar",
scoped: false,
text: `
@@ -1820,7 +1820,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
};
// emit helper for `import Name from "foo"`
export const importDefaultHelper: UnscopedEmitHelpers = {
export const importDefaultHelper: UnscopedEmitHelper = {
name: "typescript:commonjsimportdefault",
scoped: false,
text: `
src/compiler/transformers/ts.ts
+3 -3
View File
@@ -3680,7 +3680,7 @@ namespace ts {
);
}
export const decorateHelper: UnscopedEmitHelpers = {
export const decorateHelper: UnscopedEmitHelper = {
name: "typescript:decorate",
scoped: false,
priority: 2,
@@ -3705,7 +3705,7 @@ namespace ts {
);
}
export const metadataHelper: UnscopedEmitHelpers = {
export const metadataHelper: UnscopedEmitHelper = {
name: "typescript:metadata",
scoped: false,
priority: 3,
@@ -3730,7 +3730,7 @@ namespace ts {
);
}
export const paramHelper: UnscopedEmitHelpers = {
export const paramHelper: UnscopedEmitHelper = {
name: "typescript:param",
scoped: false,
priority: 4,
src/compiler/tsconfig.json
+1
View File
@@ -30,6 +30,7 @@
"transformers/destructuring.ts",
"transformers/ts.ts",
"transformers/es2017.ts",
"transformers/es2018.ts",
"transformers/esnext.ts",
"transformers/jsx.ts",
"transformers/es2016.ts",
src/compiler/types.ts
+5 -4
View File
@@ -2786,7 +2786,7 @@ namespace ts {
fileName: string;
text: string;
prologues: ReadonlyArray<UnparsedPrologue>;
helpers: ReadonlyArray<UnscopedEmitHelpers> | undefined;
helpers: ReadonlyArray<UnscopedEmitHelper> | undefined;
// References and noDefaultLibAre Dts only
referencedFiles: ReadonlyArray<FileReference>;
@@ -4176,7 +4176,6 @@ namespace ts {
templateType?: Type;
modifiersType?: Type;
resolvedApparentType?: Type;
instantiating?: boolean;
}
export interface EvolvingArrayType extends ObjectType {
@@ -5134,6 +5133,7 @@ namespace ts {
ContainsDynamicImport = 1 << 24,
Super = 1 << 25,
ContainsSuper = 1 << 26,
ContainsES2018 = 1 << 27,
// Please leave this as 1 << 29.
// It is the maximum bit we can set before we outgrow the size of a v8 small integer (SMI) on an x86 system.
@@ -5145,6 +5145,7 @@ namespace ts {
AssertTypeScript = TypeScript | ContainsTypeScript,
AssertJsx = ContainsJsx,
AssertESNext = ContainsESNext,
AssertES2018 = ContainsES2018,
AssertES2017 = ContainsES2017,
AssertES2016 = ContainsES2016,
AssertES2015 = ES2015 | ContainsES2015,
@@ -5243,7 +5244,7 @@ namespace ts {
readonly priority?: number; // Helpers with a higher priority are emitted earlier than other helpers on the node.
}
export interface UnscopedEmitHelpers extends EmitHelper {
export interface UnscopedEmitHelper extends EmitHelper {
readonly scoped: false; // Indicates whether the helper MUST be emitted in the current scope.
readonly text: string; // ES3-compatible raw script text, or a function yielding such a string
}
@@ -6018,7 +6019,7 @@ namespace ts {
export interface UserPreferences {
readonly disableSuggestions?: boolean;
readonly quotePreference?: "double" | "single";
readonly quotePreference?: "auto" | "double" | "single";
readonly includeCompletionsForModuleExports?: boolean;
readonly includeCompletionsWithInsertText?: boolean;
readonly importModuleSpecifierPreference?: "relative" | "non-relative";
src/compiler/utilities.ts
+3 -2
View File
@@ -2514,14 +2514,15 @@ namespace ts {
}
export function getEffectiveBaseTypeNode(node: ClassLikeDeclaration | InterfaceDeclaration) {
if (isInJSFile(node)) {
const baseType = getClassExtendsHeritageElement(node);
if (baseType && isInJSFile(node)) {
// Prefer an @augments tag because it may have type parameters.
const tag = getJSDocAugmentsTag(node);
if (tag) {
return tag.class;
}
}
return getClassExtendsHeritageElement(node);
return baseType;
}
export function getClassExtendsHeritageElement(node: ClassLikeDeclaration | InterfaceDeclaration) {
src/server/protocol.ts
+1 -1
View File
@@ -2891,7 +2891,7 @@ namespace ts.server.protocol {
export interface UserPreferences {
readonly disableSuggestions?: boolean;
readonly quotePreference?: "double" | "single";
readonly quotePreference?: "auto" | "double" | "single";
/**
* If enabled, TypeScript will search through all external modules' exports and add them to the completions list.
* This affects lone identifier completions but not completions on the right hand side of `obj.`.
src/services/codefixes/helpers.ts
+1
View File
@@ -264,6 +264,7 @@ namespace ts.codefix {
createNew(
createIdentifier("Error"),
/*typeArguments*/ undefined,
// TODO Handle auto quote preference.
[createLiteral("Method not implemented.", /*isSingleQuote*/ preferences.quotePreference === "single")]))],
/*multiline*/ true);
}
src/services/utilities.ts
+7 -4
View File
@@ -1315,7 +1315,7 @@ namespace ts {
}
export function getQuotePreference(sourceFile: SourceFile, preferences: UserPreferences): QuotePreference {
if (preferences.quotePreference) {
if (preferences.quotePreference && preferences.quotePreference !== "auto") {
return preferences.quotePreference === "single" ? QuotePreference.Single : QuotePreference.Double;
}
else {
@@ -1868,15 +1868,18 @@ namespace ts {
if (/^\d+$/.test(text)) {
return text;
}
// Editors can pass in undefined or empty string - we want to infer the preference in those cases.
const quotePreference = preferences.quotePreference || "auto";
const quoted = JSON.stringify(text);
switch (preferences.quotePreference) {
case undefined:
switch (quotePreference) {
// TODO use getQuotePreference to infer the actual quote style.
case "auto":
case "double":
return quoted;
case "single":
return `'${stripQuotes(quoted).replace("'", "\\'").replace('\\"', '"')}'`;
default:
return Debug.assertNever(preferences.quotePreference);
return Debug.assertNever(quotePreference);
}
}
src/testRunner/unittests/asserts.ts
+3
View File
@@ -5,5 +5,8 @@ namespace ts {
assert.throws(() => assert.deepEqual(createNodeArray([], /*hasTrailingComma*/ true), createNodeArray([], /*hasTrailingComma*/ false)));
assert.deepEqual(createNodeArray([createIdentifier("A")], /*hasTrailingComma*/ true), createNodeArray([createIdentifier("A")], /*hasTrailingComma*/ true));
});
it("assertNever on string has correct error", () => {
assert.throws(() => Debug.assertNever("hi" as never), "Debug Failure. Illegal value: \"hi\"");
});
});
}