maxmustermann/TypeScript
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity

unexpose resolveStructuredTypeMembers

Browse source
This commit is contained in:
Arthur Ozga 2016-11-15 13:56:42 -08:00
parent 43afb806de
commit 6ed8d1803b
5 changed files with 21 additions and 17 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
src/compiler/checker.ts
View file

@ -84,7 +84,6 @@ namespace ts {
getIntersectionType,
getTypeFromTypeReference,
getReturnTypeOfSignature,
resolveStructuredTypeMembers,
getNonNullableType,
getSymbolsInScope,
getSymbolAtLocation,

2
src/compiler/types.ts
View file

@ -2264,7 +2264,6 @@ namespace ts {
getSignaturesOfType(type: Type, kind: SignatureKind): Signature[];
getIndexTypeOfType(type: Type, kind: IndexKind): Type;
getBaseTypes(type: InterfaceType): ObjectType[];
resolveStructuredTypeMembers(type: StructuredType): ResolvedType;
getReturnTypeOfSignature(signature: Signature): Type;
getNonNullableType(type: Type): Type;
getIntersectionType(types: Type[], aliasSymbol?: Symbol, aliasTypeArguments?: Type[]): Type;
@ -2849,6 +2848,7 @@ namespace ts {
finalArrayType?: Type; // Final array type of evolving array type
}
/* @internal */
// Resolved object, union, or intersection type
export interface ResolvedType extends ObjectType, UnionOrIntersectionType {
members: SymbolTable; // Properties by name

9
src/services/codefixes/fixClassDoesntImplementInheritedAbstractMember.ts
View file

@ -13,9 +13,14 @@ namespace ts.codefix {
const startPos = classDecl.members.pos;
const InstantiatedExtendsType = <InterfaceType>checker.getTypeFromTypeReference(getClassExtendsHeritageClauseElement(classDecl));
const resolvedExtendsType = checker.resolveStructuredTypeMembers(InstantiatedExtendsType);
const extendsSymbols = checker.getPropertiesOfType(InstantiatedExtendsType);
let extendsAbstractSymbolsMap = createMap<Symbol>();
for (const symbol of extendsSymbols) {
extendsAbstractSymbolsMap[symbol.getName()] = symbol;
}
extendsAbstractSymbolsMap = filterAbstractAndNonPrivate(extendsAbstractSymbolsMap);
const insertion = getMissingAbstractMembersInsertion(classDecl, resolvedExtendsType, checker, context.newLineCharacter);
const insertion = getMissingMembersInsertion(classDecl, extendsAbstractSymbolsMap, checker, context.newLineCharacter);
if (insertion.length > 0) {
return [{

10
src/services/codefixes/fixClassIncorrectlyImplementsInterface.ts
View file

@ -17,12 +17,16 @@ namespace ts.codefix {
const implementedTypeNodes = getClassImplementsHeritageClauseElements(classDecl);
const implementedTypes = implementedTypeNodes.map(checker.getTypeFromTypeReference);
const resolvedImplementedTypes = implementedTypes.map(checker.resolveStructuredTypeMembers);
const implementedTypeSymbols = implementedTypes.map(checker.getPropertiesOfType);
const result: CodeAction[] = [];
for (const resolvedType of resolvedImplementedTypes) {
const insertion = getMissingMembersInsertion(classDecl, resolvedType, checker, context.newLineCharacter);
for (const symbols of implementedTypeSymbols) {
const symbolMap = createMap<Symbol>();
for (const symbol of symbols) {
symbolMap[symbol.getName()] = symbol;
}
const insertion = getMissingMembersInsertion(classDecl, filterNonPrivate(symbolMap), checker, context.newLineCharacter);
pushAction(result, insertion, getLocaleSpecificMessage(Diagnostics.Implement_interface_on_class));
}

16
src/services/utilities.ts
View file

@ -1359,17 +1359,13 @@ namespace ts {
};
}
export function getMissingAbstractMembersInsertion(classDeclaration: ClassLikeDeclaration, resolvedType: ResolvedType, checker: TypeChecker, newlineChar: string): string {
const missingMembers = filterMissingMembers(filterAbstract(filterNonPrivate(resolvedType.members)), classDeclaration.symbol.members);
return getInsertionsForMembers(missingMembers, classDeclaration, checker, newlineChar);
}
/**
* Finds members of the resolved type that are missing in the class pointed to by class decl
* and generates source code for the missing members.
* @param possiblyMissingSymbols The collection of symbols to filter.
*/
export function getMissingMembersInsertion(classDeclaration: ClassLikeDeclaration, resolvedType: ResolvedType, checker: TypeChecker, newlineChar: string): string {
const missingMembers = filterMissingMembers(filterNonPrivate(resolvedType.members), classDeclaration.symbol.members);
export function getMissingMembersInsertion(classDeclaration: ClassLikeDeclaration, possiblyMissingSymbols: Map<Symbol>, checker: TypeChecker, newlineChar: string): string {
const missingMembers = filterMissingMembers(possiblyMissingSymbols, classDeclaration.symbol.members);
return getInsertionsForMembers(missingMembers, classDeclaration, checker, newlineChar);
}
@ -1398,11 +1394,11 @@ namespace ts {
return result;
}
function filterAbstract(symbolMap: Map<Symbol>) {
return filterSymbolMapByDeclaration(symbolMap, decl => !!(getModifierFlags(decl) & ModifierFlags.Abstract));
export function filterAbstractAndNonPrivate(symbolMap: Map<Symbol>) {
return filterSymbolMapByDeclaration(symbolMap, decl => !(getModifierFlags(decl) & ModifierFlags.Private) && !!(getModifierFlags(decl) & ModifierFlags.Abstract));
}
function filterNonPrivate(symbolMap: Map<Symbol>) {
export function filterNonPrivate(symbolMap: Map<Symbol>) {
return filterSymbolMapByDeclaration(symbolMap, decl => !(getModifierFlags(decl) & ModifierFlags.Private));
}