Merge pull request #10013 from Microsoft/resolve_entity_name
Use brand types to clear up confusion about entity name expressions
This commit is contained in:
commit
e900952d3d
|
@ -1887,18 +1887,17 @@ namespace ts {
|
|||
}
|
||||
|
||||
function bindExportAssignment(node: ExportAssignment | BinaryExpression) {
|
||||
const boundExpression = node.kind === SyntaxKind.ExportAssignment ? (<ExportAssignment>node).expression : (<BinaryExpression>node).right;
|
||||
if (!container.symbol || !container.symbol.exports) {
|
||||
// Export assignment in some sort of block construct
|
||||
bindAnonymousDeclaration(node, SymbolFlags.Alias, getDeclarationName(node));
|
||||
}
|
||||
else if (boundExpression.kind === SyntaxKind.Identifier && node.kind === SyntaxKind.ExportAssignment) {
|
||||
// An export default clause with an identifier exports all meanings of that identifier
|
||||
declareSymbol(container.symbol.exports, container.symbol, node, SymbolFlags.Alias, SymbolFlags.PropertyExcludes | SymbolFlags.AliasExcludes);
|
||||
}
|
||||
else {
|
||||
// An export default clause with an expression exports a value
|
||||
declareSymbol(container.symbol.exports, container.symbol, node, SymbolFlags.Property, SymbolFlags.PropertyExcludes | SymbolFlags.AliasExcludes);
|
||||
const flags = node.kind === SyntaxKind.ExportAssignment && exportAssignmentIsAlias(<ExportAssignment>node)
|
||||
// An export default clause with an EntityNameExpression exports all meanings of that identifier
|
||||
? SymbolFlags.Alias
|
||||
// An export default clause with any other expression exports a value
|
||||
: SymbolFlags.Property;
|
||||
declareSymbol(container.symbol.exports, container.symbol, node, flags, SymbolFlags.PropertyExcludes | SymbolFlags.AliasExcludes);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
@ -664,7 +664,7 @@ namespace ts {
|
|||
// Resolve a given name for a given meaning at a given location. An error is reported if the name was not found and
|
||||
// the nameNotFoundMessage argument is not undefined. Returns the resolved symbol, or undefined if no symbol with
|
||||
// the given name can be found.
|
||||
function resolveName(location: Node, name: string, meaning: SymbolFlags, nameNotFoundMessage: DiagnosticMessage, nameArg: string | Identifier): Symbol {
|
||||
function resolveName(location: Node | undefined, name: string, meaning: SymbolFlags, nameNotFoundMessage: DiagnosticMessage, nameArg: string | Identifier): Symbol {
|
||||
let result: Symbol;
|
||||
let lastLocation: Node;
|
||||
let propertyWithInvalidInitializer: Node;
|
||||
|
@ -881,7 +881,8 @@ namespace ts {
|
|||
|
||||
if (!result) {
|
||||
if (nameNotFoundMessage) {
|
||||
if (!checkAndReportErrorForMissingPrefix(errorLocation, name, nameArg) &&
|
||||
if (!errorLocation ||
|
||||
!checkAndReportErrorForMissingPrefix(errorLocation, name, nameArg) &&
|
||||
!checkAndReportErrorForExtendingInterface(errorLocation)) {
|
||||
error(errorLocation, nameNotFoundMessage, typeof nameArg === "string" ? nameArg : declarationNameToString(nameArg));
|
||||
}
|
||||
|
@ -930,7 +931,7 @@ namespace ts {
|
|||
}
|
||||
|
||||
function checkAndReportErrorForMissingPrefix(errorLocation: Node, name: string, nameArg: string | Identifier): boolean {
|
||||
if (!errorLocation || (errorLocation.kind === SyntaxKind.Identifier && (isTypeReferenceIdentifier(<Identifier>errorLocation)) || isInTypeQuery(errorLocation))) {
|
||||
if ((errorLocation.kind === SyntaxKind.Identifier && (isTypeReferenceIdentifier(<Identifier>errorLocation)) || isInTypeQuery(errorLocation))) {
|
||||
return false;
|
||||
}
|
||||
|
||||
|
@ -968,28 +969,30 @@ namespace ts {
|
|||
|
||||
|
||||
function checkAndReportErrorForExtendingInterface(errorLocation: Node): boolean {
|
||||
let parentClassExpression = errorLocation;
|
||||
while (parentClassExpression) {
|
||||
const kind = parentClassExpression.kind;
|
||||
if (kind === SyntaxKind.Identifier || kind === SyntaxKind.PropertyAccessExpression) {
|
||||
parentClassExpression = parentClassExpression.parent;
|
||||
continue;
|
||||
}
|
||||
if (kind === SyntaxKind.ExpressionWithTypeArguments) {
|
||||
break;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
if (!parentClassExpression) {
|
||||
return false;
|
||||
}
|
||||
const expression = (<ExpressionWithTypeArguments>parentClassExpression).expression;
|
||||
if (resolveEntityName(expression, SymbolFlags.Interface, /*ignoreErrors*/ true)) {
|
||||
const expression = getEntityNameForExtendingInterface(errorLocation);
|
||||
const isError = !!(expression && resolveEntityName(expression, SymbolFlags.Interface, /*ignoreErrors*/ true));
|
||||
if (isError) {
|
||||
error(errorLocation, Diagnostics.Cannot_extend_an_interface_0_Did_you_mean_implements, getTextOfNode(expression));
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
return isError;
|
||||
}
|
||||
/**
|
||||
* Climbs up parents to an ExpressionWithTypeArguments, and returns its expression,
|
||||
* but returns undefined if that expression is not an EntityNameExpression.
|
||||
*/
|
||||
function getEntityNameForExtendingInterface(node: Node): EntityNameExpression | undefined {
|
||||
switch (node.kind) {
|
||||
case SyntaxKind.Identifier:
|
||||
case SyntaxKind.PropertyAccessExpression:
|
||||
return node.parent ? getEntityNameForExtendingInterface(node.parent) : undefined;
|
||||
case SyntaxKind.ExpressionWithTypeArguments:
|
||||
Debug.assert(isEntityNameExpression((<ExpressionWithTypeArguments>node).expression));
|
||||
return <EntityNameExpression>(<ExpressionWithTypeArguments>node).expression;
|
||||
default:
|
||||
return undefined;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
function checkResolvedBlockScopedVariable(result: Symbol, errorLocation: Node): void {
|
||||
Debug.assert((result.flags & SymbolFlags.BlockScopedVariable) !== 0);
|
||||
|
@ -1033,7 +1036,7 @@ namespace ts {
|
|||
}
|
||||
|
||||
function getDeclarationOfAliasSymbol(symbol: Symbol): Declaration {
|
||||
return forEach(symbol.declarations, d => isAliasSymbolDeclaration(d) ? d : undefined);
|
||||
return find(symbol.declarations, d => isAliasSymbolDeclaration(d) ? d : undefined);
|
||||
}
|
||||
|
||||
function getTargetOfImportEqualsDeclaration(node: ImportEqualsDeclaration): Symbol {
|
||||
|
@ -1168,7 +1171,7 @@ namespace ts {
|
|||
}
|
||||
|
||||
function getTargetOfExportAssignment(node: ExportAssignment): Symbol {
|
||||
return resolveEntityName(<Identifier>node.expression, SymbolFlags.Value | SymbolFlags.Type | SymbolFlags.Namespace);
|
||||
return resolveEntityName(<EntityNameExpression>node.expression, SymbolFlags.Value | SymbolFlags.Type | SymbolFlags.Namespace);
|
||||
}
|
||||
|
||||
function getTargetOfAliasDeclaration(node: Declaration): Symbol {
|
||||
|
@ -1278,7 +1281,7 @@ namespace ts {
|
|||
}
|
||||
|
||||
// Resolves a qualified name and any involved aliases
|
||||
function resolveEntityName(name: EntityName | Expression, meaning: SymbolFlags, ignoreErrors?: boolean, dontResolveAlias?: boolean): Symbol {
|
||||
function resolveEntityName(name: EntityNameOrEntityNameExpression, meaning: SymbolFlags, ignoreErrors?: boolean, dontResolveAlias?: boolean): Symbol | undefined {
|
||||
if (nodeIsMissing(name)) {
|
||||
return undefined;
|
||||
}
|
||||
|
@ -1293,7 +1296,7 @@ namespace ts {
|
|||
}
|
||||
}
|
||||
else if (name.kind === SyntaxKind.QualifiedName || name.kind === SyntaxKind.PropertyAccessExpression) {
|
||||
const left = name.kind === SyntaxKind.QualifiedName ? (<QualifiedName>name).left : (<PropertyAccessExpression>name).expression;
|
||||
const left = name.kind === SyntaxKind.QualifiedName ? (<QualifiedName>name).left : (<PropertyAccessEntityNameExpression>name).expression;
|
||||
const right = name.kind === SyntaxKind.QualifiedName ? (<QualifiedName>name).right : (<PropertyAccessExpression>name).name;
|
||||
|
||||
const namespace = resolveEntityName(left, SymbolFlags.Namespace, ignoreErrors);
|
||||
|
@ -1849,7 +1852,7 @@ namespace ts {
|
|||
}
|
||||
}
|
||||
|
||||
function isEntityNameVisible(entityName: EntityName | Expression, enclosingDeclaration: Node): SymbolVisibilityResult {
|
||||
function isEntityNameVisible(entityName: EntityNameOrEntityNameExpression, enclosingDeclaration: Node): SymbolVisibilityResult {
|
||||
// get symbol of the first identifier of the entityName
|
||||
let meaning: SymbolFlags;
|
||||
if (entityName.parent.kind === SyntaxKind.TypeQuery || isExpressionWithTypeArgumentsInClassExtendsClause(entityName.parent)) {
|
||||
|
@ -3679,7 +3682,7 @@ namespace ts {
|
|||
const baseTypeNodes = getInterfaceBaseTypeNodes(<InterfaceDeclaration>declaration);
|
||||
if (baseTypeNodes) {
|
||||
for (const node of baseTypeNodes) {
|
||||
if (isSupportedExpressionWithTypeArguments(node)) {
|
||||
if (isEntityNameExpression(node.expression)) {
|
||||
const baseSymbol = resolveEntityName(node.expression, SymbolFlags.Type, /*ignoreErrors*/ true);
|
||||
if (!baseSymbol || !(baseSymbol.flags & SymbolFlags.Interface) || getDeclaredTypeOfClassOrInterface(baseSymbol).thisType) {
|
||||
return false;
|
||||
|
@ -5045,7 +5048,7 @@ namespace ts {
|
|||
return getDeclaredTypeOfSymbol(symbol);
|
||||
}
|
||||
|
||||
function getTypeReferenceName(node: TypeReferenceNode | ExpressionWithTypeArguments | JSDocTypeReference): LeftHandSideExpression | EntityName {
|
||||
function getTypeReferenceName(node: TypeReferenceNode | ExpressionWithTypeArguments | JSDocTypeReference): EntityNameOrEntityNameExpression | undefined {
|
||||
switch (node.kind) {
|
||||
case SyntaxKind.TypeReference:
|
||||
return (<TypeReferenceNode>node).typeName;
|
||||
|
@ -5054,8 +5057,9 @@ namespace ts {
|
|||
case SyntaxKind.ExpressionWithTypeArguments:
|
||||
// We only support expressions that are simple qualified names. For other
|
||||
// expressions this produces undefined.
|
||||
if (isSupportedExpressionWithTypeArguments(<ExpressionWithTypeArguments>node)) {
|
||||
return (<ExpressionWithTypeArguments>node).expression;
|
||||
const expr = (<ExpressionWithTypeArguments>node).expression;
|
||||
if (isEntityNameExpression(expr)) {
|
||||
return expr;
|
||||
}
|
||||
|
||||
// fall through;
|
||||
|
@ -5066,7 +5070,7 @@ namespace ts {
|
|||
|
||||
function resolveTypeReferenceName(
|
||||
node: TypeReferenceNode | ExpressionWithTypeArguments | JSDocTypeReference,
|
||||
typeReferenceName: LeftHandSideExpression | EntityName) {
|
||||
typeReferenceName: EntityNameExpression | EntityName) {
|
||||
|
||||
if (!typeReferenceName) {
|
||||
return unknownSymbol;
|
||||
|
@ -5107,15 +5111,14 @@ namespace ts {
|
|||
const typeReferenceName = getTypeReferenceName(node);
|
||||
symbol = resolveTypeReferenceName(node, typeReferenceName);
|
||||
type = getTypeReferenceType(node, symbol);
|
||||
|
||||
links.resolvedSymbol = symbol;
|
||||
links.resolvedType = type;
|
||||
}
|
||||
else {
|
||||
// We only support expressions that are simple qualified names. For other expressions this produces undefined.
|
||||
const typeNameOrExpression = node.kind === SyntaxKind.TypeReference ? (<TypeReferenceNode>node).typeName :
|
||||
isSupportedExpressionWithTypeArguments(<ExpressionWithTypeArguments>node) ? (<ExpressionWithTypeArguments>node).expression :
|
||||
undefined;
|
||||
const typeNameOrExpression: EntityNameOrEntityNameExpression = node.kind === SyntaxKind.TypeReference
|
||||
? (<TypeReferenceNode>node).typeName
|
||||
: isEntityNameExpression((<ExpressionWithTypeArguments>node).expression)
|
||||
? <EntityNameExpression>(<ExpressionWithTypeArguments>node).expression
|
||||
: undefined;
|
||||
symbol = typeNameOrExpression && resolveEntityName(typeNameOrExpression, SymbolFlags.Type) || unknownSymbol;
|
||||
type = symbol === unknownSymbol ? unknownType :
|
||||
symbol.flags & (SymbolFlags.Class | SymbolFlags.Interface) ? getTypeFromClassOrInterfaceReference(node, symbol) :
|
||||
|
@ -16387,7 +16390,7 @@ namespace ts {
|
|||
const implementedTypeNodes = getClassImplementsHeritageClauseElements(node);
|
||||
if (implementedTypeNodes) {
|
||||
for (const typeRefNode of implementedTypeNodes) {
|
||||
if (!isSupportedExpressionWithTypeArguments(typeRefNode)) {
|
||||
if (!isEntityNameExpression(typeRefNode.expression)) {
|
||||
error(typeRefNode.expression, Diagnostics.A_class_can_only_implement_an_identifier_Slashqualified_name_with_optional_type_arguments);
|
||||
}
|
||||
checkTypeReferenceNode(typeRefNode);
|
||||
|
@ -16629,7 +16632,7 @@ namespace ts {
|
|||
checkObjectTypeForDuplicateDeclarations(node);
|
||||
}
|
||||
forEach(getInterfaceBaseTypeNodes(node), heritageElement => {
|
||||
if (!isSupportedExpressionWithTypeArguments(heritageElement)) {
|
||||
if (!isEntityNameExpression(heritageElement.expression)) {
|
||||
error(heritageElement.expression, Diagnostics.An_interface_can_only_extend_an_identifier_Slashqualified_name_with_optional_type_arguments);
|
||||
}
|
||||
checkTypeReferenceNode(heritageElement);
|
||||
|
@ -17094,20 +17097,21 @@ namespace ts {
|
|||
}
|
||||
}
|
||||
|
||||
function getFirstIdentifier(node: EntityName | Expression): Identifier {
|
||||
while (true) {
|
||||
if (node.kind === SyntaxKind.QualifiedName) {
|
||||
node = (<QualifiedName>node).left;
|
||||
}
|
||||
else if (node.kind === SyntaxKind.PropertyAccessExpression) {
|
||||
node = (<PropertyAccessExpression>node).expression;
|
||||
}
|
||||
else {
|
||||
break;
|
||||
}
|
||||
function getFirstIdentifier(node: EntityNameOrEntityNameExpression): Identifier {
|
||||
switch (node.kind) {
|
||||
case SyntaxKind.Identifier:
|
||||
return <Identifier>node;
|
||||
case SyntaxKind.QualifiedName:
|
||||
do {
|
||||
node = (<QualifiedName>node).left;
|
||||
} while (node.kind !== SyntaxKind.Identifier);
|
||||
return <Identifier>node;
|
||||
case SyntaxKind.PropertyAccessExpression:
|
||||
do {
|
||||
node = (<PropertyAccessEntityNameExpression>node).expression;
|
||||
} while (node.kind !== SyntaxKind.Identifier);
|
||||
return <Identifier>node;
|
||||
}
|
||||
Debug.assert(node.kind === SyntaxKind.Identifier);
|
||||
return <Identifier>node;
|
||||
}
|
||||
|
||||
function checkExternalImportOrExportDeclaration(node: ImportDeclaration | ImportEqualsDeclaration | ExportDeclaration): boolean {
|
||||
|
@ -17806,7 +17810,7 @@ namespace ts {
|
|||
return getLeftSideOfImportEqualsOrExportAssignment(node) !== undefined;
|
||||
}
|
||||
|
||||
function getSymbolOfEntityNameOrPropertyAccessExpression(entityName: EntityName | PropertyAccessExpression): Symbol {
|
||||
function getSymbolOfEntityNameOrPropertyAccessExpression(entityName: EntityName | PropertyAccessExpression): Symbol | undefined {
|
||||
if (isDeclarationName(entityName)) {
|
||||
return getSymbolOfNode(entityName.parent);
|
||||
}
|
||||
|
@ -17825,22 +17829,20 @@ namespace ts {
|
|||
}
|
||||
}
|
||||
|
||||
if (entityName.parent.kind === SyntaxKind.ExportAssignment) {
|
||||
return resolveEntityName(<Identifier>entityName,
|
||||
if (entityName.parent.kind === SyntaxKind.ExportAssignment && isEntityNameExpression(<Identifier | PropertyAccessExpression>entityName)) {
|
||||
return resolveEntityName(<EntityNameExpression>entityName,
|
||||
/*all meanings*/ SymbolFlags.Value | SymbolFlags.Type | SymbolFlags.Namespace | SymbolFlags.Alias);
|
||||
}
|
||||
|
||||
if (entityName.kind !== SyntaxKind.PropertyAccessExpression) {
|
||||
if (isInRightSideOfImportOrExportAssignment(<EntityName>entityName)) {
|
||||
// Since we already checked for ExportAssignment, this really could only be an Import
|
||||
const importEqualsDeclaration = <ImportEqualsDeclaration>getAncestor(entityName, SyntaxKind.ImportEqualsDeclaration);
|
||||
Debug.assert(importEqualsDeclaration !== undefined);
|
||||
return getSymbolOfPartOfRightHandSideOfImportEquals(<EntityName>entityName, importEqualsDeclaration, /*dontResolveAlias*/ true);
|
||||
}
|
||||
if (entityName.kind !== SyntaxKind.PropertyAccessExpression && isInRightSideOfImportOrExportAssignment(<EntityName>entityName)) {
|
||||
// Since we already checked for ExportAssignment, this really could only be an Import
|
||||
const importEqualsDeclaration = <ImportEqualsDeclaration>getAncestor(entityName, SyntaxKind.ImportEqualsDeclaration);
|
||||
Debug.assert(importEqualsDeclaration !== undefined);
|
||||
return getSymbolOfPartOfRightHandSideOfImportEquals(<EntityName>entityName, importEqualsDeclaration, /*dontResolveAlias*/ true);
|
||||
}
|
||||
|
||||
if (isRightSideOfQualifiedNameOrPropertyAccess(entityName)) {
|
||||
entityName = <QualifiedName | PropertyAccessExpression>entityName.parent;
|
||||
entityName = <QualifiedName | PropertyAccessEntityNameExpression>entityName.parent;
|
||||
}
|
||||
|
||||
if (isHeritageClauseElementIdentifier(<EntityName>entityName)) {
|
||||
|
@ -18553,7 +18555,7 @@ namespace ts {
|
|||
};
|
||||
|
||||
// defined here to avoid outer scope pollution
|
||||
function getTypeReferenceDirectivesForEntityName(node: EntityName | PropertyAccessExpression): string[] {
|
||||
function getTypeReferenceDirectivesForEntityName(node: EntityNameOrEntityNameExpression): string[] {
|
||||
// program does not have any files with type reference directives - bail out
|
||||
if (!fileToDirective) {
|
||||
return undefined;
|
||||
|
|
|
@ -81,7 +81,7 @@ namespace ts {
|
|||
* returns a truthy value, then returns that value.
|
||||
* If no such value is found, the callback is applied to each element of array and undefined is returned.
|
||||
*/
|
||||
export function forEach<T, U>(array: T[], callback: (element: T, index: number) => U): U {
|
||||
export function forEach<T, U>(array: T[] | undefined, callback: (element: T, index: number) => U | undefined): U | undefined {
|
||||
if (array) {
|
||||
for (let i = 0, len = array.length; i < len; i++) {
|
||||
const result = callback(array[i], i);
|
||||
|
@ -93,6 +93,17 @@ namespace ts {
|
|||
return undefined;
|
||||
}
|
||||
|
||||
/** Like `forEach`, but assumes existence of array and fails if no truthy value is found. */
|
||||
export function find<T, U>(array: T[], callback: (element: T, index: number) => U | undefined): U {
|
||||
for (let i = 0, len = array.length; i < len; i++) {
|
||||
const result = callback(array[i], i);
|
||||
if (result) {
|
||||
return result;
|
||||
}
|
||||
}
|
||||
Debug.fail();
|
||||
}
|
||||
|
||||
export function contains<T>(array: T[], value: T): boolean {
|
||||
if (array) {
|
||||
for (const v of array) {
|
||||
|
|
|
@ -441,7 +441,7 @@ namespace ts {
|
|||
}
|
||||
}
|
||||
|
||||
function emitEntityName(entityName: EntityName | PropertyAccessExpression) {
|
||||
function emitEntityName(entityName: EntityNameOrEntityNameExpression) {
|
||||
const visibilityResult = resolver.isEntityNameVisible(entityName,
|
||||
// Aliases can be written asynchronously so use correct enclosing declaration
|
||||
entityName.parent.kind === SyntaxKind.ImportEqualsDeclaration ? entityName.parent : enclosingDeclaration);
|
||||
|
@ -452,9 +452,9 @@ namespace ts {
|
|||
}
|
||||
|
||||
function emitExpressionWithTypeArguments(node: ExpressionWithTypeArguments) {
|
||||
if (isSupportedExpressionWithTypeArguments(node)) {
|
||||
if (isEntityNameExpression(node.expression)) {
|
||||
Debug.assert(node.expression.kind === SyntaxKind.Identifier || node.expression.kind === SyntaxKind.PropertyAccessExpression);
|
||||
emitEntityName(<Identifier | PropertyAccessExpression>node.expression);
|
||||
emitEntityName(node.expression);
|
||||
if (node.typeArguments) {
|
||||
write("<");
|
||||
emitCommaList(node.typeArguments, emitType);
|
||||
|
@ -1019,7 +1019,7 @@ namespace ts {
|
|||
}
|
||||
|
||||
function emitTypeOfTypeReference(node: ExpressionWithTypeArguments) {
|
||||
if (isSupportedExpressionWithTypeArguments(node)) {
|
||||
if (isEntityNameExpression(node.expression)) {
|
||||
emitTypeWithNewGetSymbolAccessibilityDiagnostic(node, getHeritageClauseVisibilityError);
|
||||
}
|
||||
else if (!isImplementsList && node.expression.kind === SyntaxKind.NullKeyword) {
|
||||
|
|
|
@ -982,13 +982,19 @@ namespace ts {
|
|||
multiLine?: boolean;
|
||||
}
|
||||
|
||||
export type EntityNameExpression = Identifier | PropertyAccessEntityNameExpression;
|
||||
export type EntityNameOrEntityNameExpression = EntityName | EntityNameExpression;
|
||||
|
||||
// @kind(SyntaxKind.PropertyAccessExpression)
|
||||
export interface PropertyAccessExpression extends MemberExpression, Declaration {
|
||||
expression: LeftHandSideExpression;
|
||||
name: Identifier;
|
||||
}
|
||||
|
||||
export type IdentifierOrPropertyAccess = Identifier | PropertyAccessExpression;
|
||||
/** Brand for a PropertyAccessExpression which, like a QualifiedName, consists of a sequence of identifiers separated by dots. */
|
||||
export interface PropertyAccessEntityNameExpression extends PropertyAccessExpression {
|
||||
_propertyAccessExpressionLikeQualifiedNameBrand?: any;
|
||||
expression: EntityNameExpression;
|
||||
}
|
||||
|
||||
// @kind(SyntaxKind.ElementAccessExpression)
|
||||
export interface ElementAccessExpression extends MemberExpression {
|
||||
|
@ -2031,7 +2037,7 @@ namespace ts {
|
|||
writeTypeOfExpression(expr: Expression, enclosingDeclaration: Node, flags: TypeFormatFlags, writer: SymbolWriter): void;
|
||||
writeBaseConstructorTypeOfClass(node: ClassLikeDeclaration, enclosingDeclaration: Node, flags: TypeFormatFlags, writer: SymbolWriter): void;
|
||||
isSymbolAccessible(symbol: Symbol, enclosingDeclaration: Node, meaning: SymbolFlags): SymbolAccessibilityResult;
|
||||
isEntityNameVisible(entityName: EntityName | Expression, enclosingDeclaration: Node): SymbolVisibilityResult;
|
||||
isEntityNameVisible(entityName: EntityNameOrEntityNameExpression, enclosingDeclaration: Node): SymbolVisibilityResult;
|
||||
// Returns the constant value this property access resolves to, or 'undefined' for a non-constant
|
||||
getConstantValue(node: EnumMember | PropertyAccessExpression | ElementAccessExpression): number;
|
||||
getReferencedValueDeclaration(reference: Identifier): Declaration;
|
||||
|
@ -2040,7 +2046,7 @@ namespace ts {
|
|||
moduleExportsSomeValue(moduleReferenceExpression: Expression): boolean;
|
||||
isArgumentsLocalBinding(node: Identifier): boolean;
|
||||
getExternalModuleFileFromDeclaration(declaration: ImportEqualsDeclaration | ImportDeclaration | ExportDeclaration | ModuleDeclaration): SourceFile;
|
||||
getTypeReferenceDirectivesForEntityName(name: EntityName | PropertyAccessExpression): string[];
|
||||
getTypeReferenceDirectivesForEntityName(name: EntityNameOrEntityNameExpression): string[];
|
||||
getTypeReferenceDirectivesForSymbol(symbol: Symbol, meaning?: SymbolFlags): string[];
|
||||
}
|
||||
|
||||
|
|
|
@ -1033,14 +1033,14 @@ namespace ts {
|
|||
&& (<PropertyAccessExpression | ElementAccessExpression>node).expression.kind === SyntaxKind.SuperKeyword;
|
||||
}
|
||||
|
||||
|
||||
export function getEntityNameFromTypeNode(node: TypeNode): EntityName | Expression {
|
||||
export function getEntityNameFromTypeNode(node: TypeNode): EntityNameOrEntityNameExpression {
|
||||
if (node) {
|
||||
switch (node.kind) {
|
||||
case SyntaxKind.TypeReference:
|
||||
return (<TypeReferenceNode>node).typeName;
|
||||
case SyntaxKind.ExpressionWithTypeArguments:
|
||||
return (<ExpressionWithTypeArguments>node).expression;
|
||||
Debug.assert(isEntityNameExpression((<ExpressionWithTypeArguments>node).expression));
|
||||
return <EntityNameExpression>(<ExpressionWithTypeArguments>node).expression;
|
||||
case SyntaxKind.Identifier:
|
||||
case SyntaxKind.QualifiedName:
|
||||
return (<EntityName><Node>node);
|
||||
|
@ -1694,8 +1694,8 @@ namespace ts {
|
|||
// import * as <symbol> from ...
|
||||
// import { x as <symbol> } from ...
|
||||
// export { x as <symbol> } from ...
|
||||
// export = ...
|
||||
// export default ...
|
||||
// export = <EntityNameExpression>
|
||||
// export default <EntityNameExpression>
|
||||
export function isAliasSymbolDeclaration(node: Node): boolean {
|
||||
return node.kind === SyntaxKind.ImportEqualsDeclaration ||
|
||||
node.kind === SyntaxKind.NamespaceExportDeclaration ||
|
||||
|
@ -1703,7 +1703,11 @@ namespace ts {
|
|||
node.kind === SyntaxKind.NamespaceImport ||
|
||||
node.kind === SyntaxKind.ImportSpecifier ||
|
||||
node.kind === SyntaxKind.ExportSpecifier ||
|
||||
node.kind === SyntaxKind.ExportAssignment && (<ExportAssignment>node).expression.kind === SyntaxKind.Identifier;
|
||||
node.kind === SyntaxKind.ExportAssignment && exportAssignmentIsAlias(<ExportAssignment>node);
|
||||
}
|
||||
|
||||
export function exportAssignmentIsAlias(node: ExportAssignment): boolean {
|
||||
return isEntityNameExpression(node.expression);
|
||||
}
|
||||
|
||||
export function getClassExtendsHeritageClauseElement(node: ClassLikeDeclaration | InterfaceDeclaration) {
|
||||
|
@ -2681,22 +2685,9 @@ namespace ts {
|
|||
isClassLike(node.parent.parent);
|
||||
}
|
||||
|
||||
// Returns false if this heritage clause element's expression contains something unsupported
|
||||
// (i.e. not a name or dotted name).
|
||||
export function isSupportedExpressionWithTypeArguments(node: ExpressionWithTypeArguments): boolean {
|
||||
return isSupportedExpressionWithTypeArgumentsRest(node.expression);
|
||||
}
|
||||
|
||||
function isSupportedExpressionWithTypeArgumentsRest(node: Expression): boolean {
|
||||
if (node.kind === SyntaxKind.Identifier) {
|
||||
return true;
|
||||
}
|
||||
else if (isPropertyAccessExpression(node)) {
|
||||
return isSupportedExpressionWithTypeArgumentsRest(node.expression);
|
||||
}
|
||||
else {
|
||||
return false;
|
||||
}
|
||||
export function isEntityNameExpression(node: Expression): node is EntityNameExpression {
|
||||
return node.kind === SyntaxKind.Identifier ||
|
||||
node.kind === SyntaxKind.PropertyAccessExpression && isEntityNameExpression((<PropertyAccessExpression>node).expression);
|
||||
}
|
||||
|
||||
export function isRightSideOfQualifiedNameOrPropertyAccess(node: Node) {
|
||||
|
|
76
tests/baselines/reference/exportDefaultProperty.js
Normal file
76
tests/baselines/reference/exportDefaultProperty.js
Normal file
|
@ -0,0 +1,76 @@
|
|||
//// [tests/cases/compiler/exportDefaultProperty.ts] ////
|
||||
|
||||
//// [declarations.d.ts]
|
||||
// This test is just like exportEqualsProperty, but with `export default`.
|
||||
|
||||
declare namespace foo.bar {
|
||||
export type X = number;
|
||||
export const X: number;
|
||||
}
|
||||
|
||||
declare module "foobar" {
|
||||
export default foo.bar;
|
||||
}
|
||||
|
||||
declare module "foobarx" {
|
||||
export default foo.bar.X;
|
||||
}
|
||||
|
||||
//// [a.ts]
|
||||
namespace A {
|
||||
export class B { constructor(b: number) {} }
|
||||
export namespace B { export const b: number = 0; }
|
||||
}
|
||||
export default A.B;
|
||||
|
||||
//// [b.ts]
|
||||
export default "foo".length;
|
||||
|
||||
//// [index.ts]
|
||||
/// <reference path="declarations.d.ts" />
|
||||
import fooBar from "foobar";
|
||||
import X = fooBar.X;
|
||||
import X2 from "foobarx";
|
||||
const x: X = X;
|
||||
const x2: X2 = X2;
|
||||
|
||||
import B from "./a";
|
||||
const b: B = new B(B.b);
|
||||
|
||||
import fooLength from "./b";
|
||||
fooLength + 1;
|
||||
|
||||
|
||||
//// [a.js]
|
||||
"use strict";
|
||||
var A;
|
||||
(function (A) {
|
||||
var B = (function () {
|
||||
function B(b) {
|
||||
}
|
||||
return B;
|
||||
}());
|
||||
A.B = B;
|
||||
var B;
|
||||
(function (B) {
|
||||
B.b = 0;
|
||||
})(B = A.B || (A.B = {}));
|
||||
})(A || (A = {}));
|
||||
exports.__esModule = true;
|
||||
exports["default"] = A.B;
|
||||
//// [b.js]
|
||||
"use strict";
|
||||
exports.__esModule = true;
|
||||
exports["default"] = "foo".length;
|
||||
//// [index.js]
|
||||
"use strict";
|
||||
/// <reference path="declarations.d.ts" />
|
||||
var foobar_1 = require("foobar");
|
||||
var X = foobar_1["default"].X;
|
||||
var foobarx_1 = require("foobarx");
|
||||
var x = X;
|
||||
var x2 = foobarx_1["default"];
|
||||
var a_1 = require("./a");
|
||||
var b = new a_1["default"](a_1["default"].b);
|
||||
var b_1 = require("./b");
|
||||
b_1["default"] + 1;
|
92
tests/baselines/reference/exportDefaultProperty.symbols
Normal file
92
tests/baselines/reference/exportDefaultProperty.symbols
Normal file
|
@ -0,0 +1,92 @@
|
|||
=== tests/cases/compiler/index.ts ===
|
||||
/// <reference path="declarations.d.ts" />
|
||||
import fooBar from "foobar";
|
||||
>fooBar : Symbol(fooBar, Decl(index.ts, 1, 6))
|
||||
|
||||
import X = fooBar.X;
|
||||
>X : Symbol(X, Decl(index.ts, 1, 28))
|
||||
>fooBar : Symbol(fooBar, Decl(index.ts, 1, 6))
|
||||
>X : Symbol(fooBar.X, Decl(declarations.d.ts, 2, 27), Decl(declarations.d.ts, 4, 16))
|
||||
|
||||
import X2 from "foobarx";
|
||||
>X2 : Symbol(X2, Decl(index.ts, 3, 6))
|
||||
|
||||
const x: X = X;
|
||||
>x : Symbol(x, Decl(index.ts, 4, 5))
|
||||
>X : Symbol(X, Decl(index.ts, 1, 28))
|
||||
>X : Symbol(X, Decl(index.ts, 1, 28))
|
||||
|
||||
const x2: X2 = X2;
|
||||
>x2 : Symbol(x2, Decl(index.ts, 5, 5))
|
||||
>X2 : Symbol(X2, Decl(index.ts, 3, 6))
|
||||
>X2 : Symbol(X2, Decl(index.ts, 3, 6))
|
||||
|
||||
import B from "./a";
|
||||
>B : Symbol(B, Decl(index.ts, 7, 6))
|
||||
|
||||
const b: B = new B(B.b);
|
||||
>b : Symbol(b, Decl(index.ts, 8, 5))
|
||||
>B : Symbol(B, Decl(index.ts, 7, 6))
|
||||
>B : Symbol(B, Decl(index.ts, 7, 6))
|
||||
>B.b : Symbol(B.b, Decl(a.ts, 2, 37))
|
||||
>B : Symbol(B, Decl(index.ts, 7, 6))
|
||||
>b : Symbol(B.b, Decl(a.ts, 2, 37))
|
||||
|
||||
import fooLength from "./b";
|
||||
>fooLength : Symbol(fooLength, Decl(index.ts, 10, 6))
|
||||
|
||||
fooLength + 1;
|
||||
>fooLength : Symbol(fooLength, Decl(index.ts, 10, 6))
|
||||
|
||||
=== tests/cases/compiler/declarations.d.ts ===
|
||||
// This test is just like exportEqualsProperty, but with `export default`.
|
||||
|
||||
declare namespace foo.bar {
|
||||
>foo : Symbol(foo, Decl(declarations.d.ts, 0, 0))
|
||||
>bar : Symbol(bar, Decl(declarations.d.ts, 2, 22))
|
||||
|
||||
export type X = number;
|
||||
>X : Symbol(X, Decl(declarations.d.ts, 2, 27), Decl(declarations.d.ts, 4, 16))
|
||||
|
||||
export const X: number;
|
||||
>X : Symbol(X, Decl(declarations.d.ts, 2, 27), Decl(declarations.d.ts, 4, 16))
|
||||
}
|
||||
|
||||
declare module "foobar" {
|
||||
export default foo.bar;
|
||||
>foo.bar : Symbol(default, Decl(declarations.d.ts, 2, 22))
|
||||
>foo : Symbol(foo, Decl(declarations.d.ts, 0, 0))
|
||||
>bar : Symbol(default, Decl(declarations.d.ts, 2, 22))
|
||||
}
|
||||
|
||||
declare module "foobarx" {
|
||||
export default foo.bar.X;
|
||||
>foo.bar.X : Symbol(default, Decl(declarations.d.ts, 2, 27), Decl(declarations.d.ts, 4, 16))
|
||||
>foo.bar : Symbol(foo.bar, Decl(declarations.d.ts, 2, 22))
|
||||
>foo : Symbol(foo, Decl(declarations.d.ts, 0, 0))
|
||||
>bar : Symbol(foo.bar, Decl(declarations.d.ts, 2, 22))
|
||||
>X : Symbol(default, Decl(declarations.d.ts, 2, 27), Decl(declarations.d.ts, 4, 16))
|
||||
}
|
||||
|
||||
=== tests/cases/compiler/a.ts ===
|
||||
namespace A {
|
||||
>A : Symbol(A, Decl(a.ts, 0, 0))
|
||||
|
||||
export class B { constructor(b: number) {} }
|
||||
>B : Symbol(B, Decl(a.ts, 0, 13), Decl(a.ts, 1, 48))
|
||||
>b : Symbol(b, Decl(a.ts, 1, 33))
|
||||
|
||||
export namespace B { export const b: number = 0; }
|
||||
>B : Symbol(B, Decl(a.ts, 0, 13), Decl(a.ts, 1, 48))
|
||||
>b : Symbol(b, Decl(a.ts, 2, 37))
|
||||
}
|
||||
export default A.B;
|
||||
>A.B : Symbol(default, Decl(a.ts, 0, 13), Decl(a.ts, 1, 48))
|
||||
>A : Symbol(A, Decl(a.ts, 0, 0))
|
||||
>B : Symbol(default, Decl(a.ts, 0, 13), Decl(a.ts, 1, 48))
|
||||
|
||||
=== tests/cases/compiler/b.ts ===
|
||||
export default "foo".length;
|
||||
>"foo".length : Symbol(String.length, Decl(lib.d.ts, --, --))
|
||||
>length : Symbol(String.length, Decl(lib.d.ts, --, --))
|
||||
|
97
tests/baselines/reference/exportDefaultProperty.types
Normal file
97
tests/baselines/reference/exportDefaultProperty.types
Normal file
|
@ -0,0 +1,97 @@
|
|||
=== tests/cases/compiler/index.ts ===
|
||||
/// <reference path="declarations.d.ts" />
|
||||
import fooBar from "foobar";
|
||||
>fooBar : typeof fooBar
|
||||
|
||||
import X = fooBar.X;
|
||||
>X : number
|
||||
>fooBar : typeof fooBar
|
||||
>X : number
|
||||
|
||||
import X2 from "foobarx";
|
||||
>X2 : number
|
||||
|
||||
const x: X = X;
|
||||
>x : number
|
||||
>X : number
|
||||
>X : number
|
||||
|
||||
const x2: X2 = X2;
|
||||
>x2 : number
|
||||
>X2 : number
|
||||
>X2 : number
|
||||
|
||||
import B from "./a";
|
||||
>B : typeof B
|
||||
|
||||
const b: B = new B(B.b);
|
||||
>b : B
|
||||
>B : B
|
||||
>new B(B.b) : B
|
||||
>B : typeof B
|
||||
>B.b : number
|
||||
>B : typeof B
|
||||
>b : number
|
||||
|
||||
import fooLength from "./b";
|
||||
>fooLength : number
|
||||
|
||||
fooLength + 1;
|
||||
>fooLength + 1 : number
|
||||
>fooLength : number
|
||||
>1 : number
|
||||
|
||||
=== tests/cases/compiler/declarations.d.ts ===
|
||||
// This test is just like exportEqualsProperty, but with `export default`.
|
||||
|
||||
declare namespace foo.bar {
|
||||
>foo : typeof foo
|
||||
>bar : typeof bar
|
||||
|
||||
export type X = number;
|
||||
>X : number
|
||||
|
||||
export const X: number;
|
||||
>X : number
|
||||
}
|
||||
|
||||
declare module "foobar" {
|
||||
export default foo.bar;
|
||||
>foo.bar : typeof default
|
||||
>foo : typeof foo
|
||||
>bar : typeof default
|
||||
}
|
||||
|
||||
declare module "foobarx" {
|
||||
export default foo.bar.X;
|
||||
>foo.bar.X : number
|
||||
>foo.bar : typeof foo.bar
|
||||
>foo : typeof foo
|
||||
>bar : typeof foo.bar
|
||||
>X : number
|
||||
}
|
||||
|
||||
=== tests/cases/compiler/a.ts ===
|
||||
namespace A {
|
||||
>A : typeof A
|
||||
|
||||
export class B { constructor(b: number) {} }
|
||||
>B : B
|
||||
>b : number
|
||||
|
||||
export namespace B { export const b: number = 0; }
|
||||
>B : typeof B
|
||||
>b : number
|
||||
>0 : number
|
||||
}
|
||||
export default A.B;
|
||||
>A.B : typeof default
|
||||
>A : typeof A
|
||||
>B : typeof default
|
||||
|
||||
=== tests/cases/compiler/b.ts ===
|
||||
export default "foo".length;
|
||||
>"foo".length : number
|
||||
>"foo" : string
|
||||
>length : number
|
||||
|
72
tests/baselines/reference/exportEqualsProperty.js
Normal file
72
tests/baselines/reference/exportEqualsProperty.js
Normal file
|
@ -0,0 +1,72 @@
|
|||
//// [tests/cases/compiler/exportEqualsProperty.ts] ////
|
||||
|
||||
//// [declarations.d.ts]
|
||||
// This test is just like exportDefaultProperty, but with `export =`.
|
||||
|
||||
declare namespace foo.bar {
|
||||
export type X = number;
|
||||
export const X: number;
|
||||
}
|
||||
|
||||
declare module "foobar" {
|
||||
export = foo.bar;
|
||||
}
|
||||
|
||||
declare module "foobarx" {
|
||||
export = foo.bar.X;
|
||||
}
|
||||
|
||||
//// [a.ts]
|
||||
namespace A {
|
||||
export class B { constructor(b: number) {} }
|
||||
export namespace B { export const b: number = 0; }
|
||||
}
|
||||
export = A.B;
|
||||
|
||||
//// [b.ts]
|
||||
export = "foo".length;
|
||||
|
||||
//// [index.ts]
|
||||
/// <reference path="declarations.d.ts" />
|
||||
import { X } from "foobar";
|
||||
import X2 = require("foobarx");
|
||||
const x: X = X;
|
||||
const x2: X2 = X2;
|
||||
|
||||
import B = require("./a");
|
||||
const b: B = new B(B.b);
|
||||
|
||||
import fooLength = require("./b");
|
||||
fooLength + 1;
|
||||
|
||||
|
||||
//// [a.js]
|
||||
"use strict";
|
||||
var A;
|
||||
(function (A) {
|
||||
var B = (function () {
|
||||
function B(b) {
|
||||
}
|
||||
return B;
|
||||
}());
|
||||
A.B = B;
|
||||
var B;
|
||||
(function (B) {
|
||||
B.b = 0;
|
||||
})(B = A.B || (A.B = {}));
|
||||
})(A || (A = {}));
|
||||
module.exports = A.B;
|
||||
//// [b.js]
|
||||
"use strict";
|
||||
module.exports = "foo".length;
|
||||
//// [index.js]
|
||||
"use strict";
|
||||
/// <reference path="declarations.d.ts" />
|
||||
var foobar_1 = require("foobar");
|
||||
var X2 = require("foobarx");
|
||||
var x = foobar_1.X;
|
||||
var x2 = X2;
|
||||
var B = require("./a");
|
||||
var b = new B(B.b);
|
||||
var fooLength = require("./b");
|
||||
fooLength + 1;
|
87
tests/baselines/reference/exportEqualsProperty.symbols
Normal file
87
tests/baselines/reference/exportEqualsProperty.symbols
Normal file
|
@ -0,0 +1,87 @@
|
|||
=== tests/cases/compiler/index.ts ===
|
||||
/// <reference path="declarations.d.ts" />
|
||||
import { X } from "foobar";
|
||||
>X : Symbol(X, Decl(index.ts, 1, 8))
|
||||
|
||||
import X2 = require("foobarx");
|
||||
>X2 : Symbol(X2, Decl(index.ts, 1, 27))
|
||||
|
||||
const x: X = X;
|
||||
>x : Symbol(x, Decl(index.ts, 3, 5))
|
||||
>X : Symbol(X, Decl(index.ts, 1, 8))
|
||||
>X : Symbol(X, Decl(index.ts, 1, 8))
|
||||
|
||||
const x2: X2 = X2;
|
||||
>x2 : Symbol(x2, Decl(index.ts, 4, 5))
|
||||
>X2 : Symbol(X2, Decl(index.ts, 1, 27))
|
||||
>X2 : Symbol(X2, Decl(index.ts, 1, 27))
|
||||
|
||||
import B = require("./a");
|
||||
>B : Symbol(B, Decl(index.ts, 4, 18))
|
||||
|
||||
const b: B = new B(B.b);
|
||||
>b : Symbol(b, Decl(index.ts, 7, 5))
|
||||
>B : Symbol(B, Decl(index.ts, 4, 18))
|
||||
>B : Symbol(B, Decl(index.ts, 4, 18))
|
||||
>B.b : Symbol(B.b, Decl(a.ts, 2, 37))
|
||||
>B : Symbol(B, Decl(index.ts, 4, 18))
|
||||
>b : Symbol(B.b, Decl(a.ts, 2, 37))
|
||||
|
||||
import fooLength = require("./b");
|
||||
>fooLength : Symbol(fooLength, Decl(index.ts, 7, 24))
|
||||
|
||||
fooLength + 1;
|
||||
>fooLength : Symbol(fooLength, Decl(index.ts, 7, 24))
|
||||
|
||||
=== tests/cases/compiler/declarations.d.ts ===
|
||||
// This test is just like exportDefaultProperty, but with `export =`.
|
||||
|
||||
declare namespace foo.bar {
|
||||
>foo : Symbol(foo, Decl(declarations.d.ts, 0, 0))
|
||||
>bar : Symbol(bar, Decl(declarations.d.ts, 2, 22))
|
||||
|
||||
export type X = number;
|
||||
>X : Symbol(X, Decl(declarations.d.ts, 2, 27), Decl(declarations.d.ts, 4, 16))
|
||||
|
||||
export const X: number;
|
||||
>X : Symbol(X, Decl(declarations.d.ts, 2, 27), Decl(declarations.d.ts, 4, 16))
|
||||
}
|
||||
|
||||
declare module "foobar" {
|
||||
export = foo.bar;
|
||||
>foo.bar : Symbol(foo.bar, Decl(declarations.d.ts, 2, 22))
|
||||
>foo : Symbol(foo, Decl(declarations.d.ts, 0, 0))
|
||||
>bar : Symbol(foo.bar, Decl(declarations.d.ts, 2, 22))
|
||||
}
|
||||
|
||||
declare module "foobarx" {
|
||||
export = foo.bar.X;
|
||||
>foo.bar.X : Symbol(foo.bar.X, Decl(declarations.d.ts, 2, 27), Decl(declarations.d.ts, 4, 16))
|
||||
>foo.bar : Symbol(foo.bar, Decl(declarations.d.ts, 2, 22))
|
||||
>foo : Symbol(foo, Decl(declarations.d.ts, 0, 0))
|
||||
>bar : Symbol(foo.bar, Decl(declarations.d.ts, 2, 22))
|
||||
>X : Symbol(foo.bar.X, Decl(declarations.d.ts, 2, 27), Decl(declarations.d.ts, 4, 16))
|
||||
}
|
||||
|
||||
=== tests/cases/compiler/a.ts ===
|
||||
namespace A {
|
||||
>A : Symbol(A, Decl(a.ts, 0, 0))
|
||||
|
||||
export class B { constructor(b: number) {} }
|
||||
>B : Symbol(B, Decl(a.ts, 0, 13), Decl(a.ts, 1, 48))
|
||||
>b : Symbol(b, Decl(a.ts, 1, 33))
|
||||
|
||||
export namespace B { export const b: number = 0; }
|
||||
>B : Symbol(B, Decl(a.ts, 0, 13), Decl(a.ts, 1, 48))
|
||||
>b : Symbol(b, Decl(a.ts, 2, 37))
|
||||
}
|
||||
export = A.B;
|
||||
>A.B : Symbol(A.B, Decl(a.ts, 0, 13), Decl(a.ts, 1, 48))
|
||||
>A : Symbol(A, Decl(a.ts, 0, 0))
|
||||
>B : Symbol(A.B, Decl(a.ts, 0, 13), Decl(a.ts, 1, 48))
|
||||
|
||||
=== tests/cases/compiler/b.ts ===
|
||||
export = "foo".length;
|
||||
>"foo".length : Symbol(String.length, Decl(lib.d.ts, --, --))
|
||||
>length : Symbol(String.length, Decl(lib.d.ts, --, --))
|
||||
|
92
tests/baselines/reference/exportEqualsProperty.types
Normal file
92
tests/baselines/reference/exportEqualsProperty.types
Normal file
|
@ -0,0 +1,92 @@
|
|||
=== tests/cases/compiler/index.ts ===
|
||||
/// <reference path="declarations.d.ts" />
|
||||
import { X } from "foobar";
|
||||
>X : number
|
||||
|
||||
import X2 = require("foobarx");
|
||||
>X2 : number
|
||||
|
||||
const x: X = X;
|
||||
>x : number
|
||||
>X : number
|
||||
>X : number
|
||||
|
||||
const x2: X2 = X2;
|
||||
>x2 : number
|
||||
>X2 : number
|
||||
>X2 : number
|
||||
|
||||
import B = require("./a");
|
||||
>B : typeof B
|
||||
|
||||
const b: B = new B(B.b);
|
||||
>b : B
|
||||
>B : B
|
||||
>new B(B.b) : B
|
||||
>B : typeof B
|
||||
>B.b : number
|
||||
>B : typeof B
|
||||
>b : number
|
||||
|
||||
import fooLength = require("./b");
|
||||
>fooLength : number
|
||||
|
||||
fooLength + 1;
|
||||
>fooLength + 1 : number
|
||||
>fooLength : number
|
||||
>1 : number
|
||||
|
||||
=== tests/cases/compiler/declarations.d.ts ===
|
||||
// This test is just like exportDefaultProperty, but with `export =`.
|
||||
|
||||
declare namespace foo.bar {
|
||||
>foo : typeof foo
|
||||
>bar : typeof bar
|
||||
|
||||
export type X = number;
|
||||
>X : number
|
||||
|
||||
export const X: number;
|
||||
>X : number
|
||||
}
|
||||
|
||||
declare module "foobar" {
|
||||
export = foo.bar;
|
||||
>foo.bar : typeof foo.bar
|
||||
>foo : typeof foo
|
||||
>bar : typeof foo.bar
|
||||
}
|
||||
|
||||
declare module "foobarx" {
|
||||
export = foo.bar.X;
|
||||
>foo.bar.X : number
|
||||
>foo.bar : typeof foo.bar
|
||||
>foo : typeof foo
|
||||
>bar : typeof foo.bar
|
||||
>X : number
|
||||
}
|
||||
|
||||
=== tests/cases/compiler/a.ts ===
|
||||
namespace A {
|
||||
>A : typeof A
|
||||
|
||||
export class B { constructor(b: number) {} }
|
||||
>B : B
|
||||
>b : number
|
||||
|
||||
export namespace B { export const b: number = 0; }
|
||||
>B : typeof B
|
||||
>b : number
|
||||
>0 : number
|
||||
}
|
||||
export = A.B;
|
||||
>A.B : typeof A.B
|
||||
>A : typeof A
|
||||
>B : typeof A.B
|
||||
|
||||
=== tests/cases/compiler/b.ts ===
|
||||
export = "foo".length;
|
||||
>"foo".length : number
|
||||
>"foo" : string
|
||||
>length : number
|
||||
|
39
tests/cases/compiler/exportDefaultProperty.ts
Normal file
39
tests/cases/compiler/exportDefaultProperty.ts
Normal file
|
@ -0,0 +1,39 @@
|
|||
// This test is just like exportEqualsProperty, but with `export default`.
|
||||
|
||||
// @Filename: declarations.d.ts
|
||||
declare namespace foo.bar {
|
||||
export type X = number;
|
||||
export const X: number;
|
||||
}
|
||||
|
||||
declare module "foobar" {
|
||||
export default foo.bar;
|
||||
}
|
||||
|
||||
declare module "foobarx" {
|
||||
export default foo.bar.X;
|
||||
}
|
||||
|
||||
// @Filename: a.ts
|
||||
namespace A {
|
||||
export class B { constructor(b: number) {} }
|
||||
export namespace B { export const b: number = 0; }
|
||||
}
|
||||
export default A.B;
|
||||
|
||||
// @Filename: b.ts
|
||||
export default "foo".length;
|
||||
|
||||
// @Filename: index.ts
|
||||
/// <reference path="declarations.d.ts" />
|
||||
import fooBar from "foobar";
|
||||
import X = fooBar.X;
|
||||
import X2 from "foobarx";
|
||||
const x: X = X;
|
||||
const x2: X2 = X2;
|
||||
|
||||
import B from "./a";
|
||||
const b: B = new B(B.b);
|
||||
|
||||
import fooLength from "./b";
|
||||
fooLength + 1;
|
38
tests/cases/compiler/exportEqualsProperty.ts
Normal file
38
tests/cases/compiler/exportEqualsProperty.ts
Normal file
|
@ -0,0 +1,38 @@
|
|||
// This test is just like exportDefaultProperty, but with `export =`.
|
||||
|
||||
// @Filename: declarations.d.ts
|
||||
declare namespace foo.bar {
|
||||
export type X = number;
|
||||
export const X: number;
|
||||
}
|
||||
|
||||
declare module "foobar" {
|
||||
export = foo.bar;
|
||||
}
|
||||
|
||||
declare module "foobarx" {
|
||||
export = foo.bar.X;
|
||||
}
|
||||
|
||||
// @Filename: a.ts
|
||||
namespace A {
|
||||
export class B { constructor(b: number) {} }
|
||||
export namespace B { export const b: number = 0; }
|
||||
}
|
||||
export = A.B;
|
||||
|
||||
// @Filename: b.ts
|
||||
export = "foo".length;
|
||||
|
||||
// @Filename: index.ts
|
||||
/// <reference path="declarations.d.ts" />
|
||||
import { X } from "foobar";
|
||||
import X2 = require("foobarx");
|
||||
const x: X = X;
|
||||
const x2: X2 = X2;
|
||||
|
||||
import B = require("./a");
|
||||
const b: B = new B(B.b);
|
||||
|
||||
import fooLength = require("./b");
|
||||
fooLength + 1;
|
Loading…
Reference in a new issue