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

Move the symbol classification and display parts writing to the Services and format the newlines correctly

Browse Source
This commit is contained in:
Sheetal Nandi
2014-09-30 17:08:59 -07:00
parent 743046bf45
commit 90e2c362a5
47 changed files with 373 additions and 369 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/compiler/checker.ts
+31 -171
View File
@@ -23,34 +23,32 @@ module ts {
return undefined;
}
interface SymbolWriter {
writeKind(text: string, kind: SymbolDisplayPartKind): void;
writeSymbol(text: string, symbol: Symbol): void;
writeLine(): void;
increaseIndent(): void;
decreaseIndent(): void;
clear(): void;
// Called when the symbol writer encounters a symbol to write. Currently only used by the
// declaration emitter to help determine if it should patch up the final declaration file
// with import statements it previously saw (but chose not to emit).
trackSymbol(symbol: Symbol, enclosingDeclaration?: Node, meaning?: SymbolFlags): void;
}
interface DisplayPartsSymbolWriter extends SymbolWriter {
displayParts(): SymbolDisplayPart[];
}
interface StringSymbolWriter extends SymbolWriter {
export interface StringSymbolWriter extends SymbolWriter {
string(): string;
}
// TODO this should go back in services
export function getSymbolDisplayPart(text: string, kind: SymbolDisplayPartKind, symbol?: Symbol): SymbolDisplayPart {
return <SymbolDisplayPart> {
text: text,
kind: kind
};
// Pool writers to avoid needing to allocate them for every symbol we write.
var stringWriters: StringSymbolWriter[] = [];
export function getSingleLineStringWriter(): StringSymbolWriter {
if (stringWriters.length == 0) {
var str = "";
return {
string: () => str,
writeKind: text => str += text,
writeSymbol: text => str += text,
// Completely ignore indentation for string writers. And map newlines to
// a single space.
writeLine: () => str += " ",
increaseIndent: () => { },
decreaseIndent: () => { },
clear: () => str = "",
trackSymbol: () => { }
};
}
return stringWriters.pop();
}
/// fullTypeCheck denotes if this instance of the typechecker will be used to get semantic diagnostics.
@@ -92,9 +90,9 @@ module ts {
getTypeOfNode: getTypeOfNode,
getApparentType: getApparentType,
typeToString: typeToString,
typeToDisplayParts: typeToDisplayParts,
writeType: writeType,
symbolToString: symbolToString,
symbolToDisplayParts: symbolToDisplayParts,
writeSymbol: writeSymbol,
getAugmentedPropertiesOfApparentType: getAugmentedPropertiesOfApparentType,
getRootSymbol: getRootSymbol,
getContextualType: getContextualType,
@@ -930,58 +928,6 @@ module ts {
{ accessibility: SymbolAccessibility.NotAccessible, errorSymbolName: firstIdentifierName };
}
// Pool writers to avoid needing to allocate them for every symbol we write.
var displayPartWriters: DisplayPartsSymbolWriter[] = [];
var stringWriters: StringSymbolWriter[] = [];
function getDisplayPartWriter(): DisplayPartsSymbolWriter {
if (displayPartWriters.length == 0) {
var displayParts: SymbolDisplayPart[] = [];
return {
displayParts: () => displayParts,
writeKind: (text, kind) => displayParts.push(getSymbolDisplayPart(text, kind)),
writeSymbol: (text, symbol) => displayParts.push(symbolPart(text, symbol)),
// Completely ignore indentation for display part writers. And map newlines to
// a single space.
writeLine: () => displayParts.push(spacePart()),
increaseIndent: () => { },
decreaseIndent: () => { },
clear: () => displayParts = [],
trackSymbol: () => { }
};
}
return displayPartWriters.pop();
}
function getStringWriter(): StringSymbolWriter {
if (stringWriters.length == 0) {
var str = "";
return {
string: () => str,
writeKind: text => str += text,
writeSymbol: text => str += text,
// Completely ignore indentation for string writers. And map newlines to
// a single space.
writeLine: () => str += " ",
increaseIndent: () => { },
decreaseIndent: () => { },
clear: () => str = "",
trackSymbol: () => { }
};
}
return stringWriters.pop();
}
function releaseDisplayPartWriter(writer: DisplayPartsSymbolWriter) {
writer.clear();
displayPartWriters.push(writer);
}
function releaseStringWriter(writer: StringSymbolWriter) {
writer.clear()
stringWriters.push(writer);
@@ -1004,7 +950,7 @@ module ts {
}
function symbolToString(symbol: Symbol, enclosingDeclaration?: Node, meaning?: SymbolFlags): string {
var writer = getStringWriter();
var writer = getSingleLineStringWriter();
writeSymbol(symbol, writer, enclosingDeclaration, meaning);
var result = writer.string();
@@ -1013,16 +959,6 @@ module ts {
return result;
}
function symbolToDisplayParts(symbol: Symbol, enclosingDeclaration?: Node, meaning?: SymbolFlags): SymbolDisplayPart[] {
var writer = getDisplayPartWriter();
writeSymbol(symbol, writer, enclosingDeclaration, meaning);
var result = writer.displayParts();
releaseDisplayPartWriter(writer);
return result;
}
// Enclosing declaration is optional when we don't want to get qualified name in the enclosing declaration scope
// Meaning needs to be specified if the enclosing declaration is given
function writeSymbol(symbol: Symbol, writer: SymbolWriter, enclosingDeclaration?: Node, meaning?: SymbolFlags): void {
@@ -1099,12 +1035,8 @@ module ts {
return writeSymbolName(symbol);
}
function writeSymbolToTextWriter(symbol: Symbol, enclosingDeclaration: Node, meaning: SymbolFlags, writer: TextWriter) {
writer.write(symbolToString(symbol, enclosingDeclaration, meaning));
}
function typeToString(type: Type, enclosingDeclaration?: Node, flags?: TypeFormatFlags): string {
var writer = getStringWriter();
var writer = getSingleLineStringWriter();
writeType(type, writer, enclosingDeclaration, flags);
var result = writer.string();
@@ -1118,16 +1050,6 @@ module ts {
return result;
}
function typeToDisplayParts(type: Type, enclosingDeclaration?: Node, flags?: TypeFormatFlags): SymbolDisplayPart[] {
var writer = getDisplayPartWriter();
writeType(type, writer, enclosingDeclaration, flags);
var result = writer.displayParts();
releaseDisplayPartWriter(writer);
return result;
}
function writeType(type: Type, writer: SymbolWriter, enclosingDeclaration?: Node, flags?: TypeFormatFlags) {
var typeStack: Type[];
return writeType(type, /*allowFunctionOrConstructorTypeLiteral*/ true);
@@ -7620,34 +7542,17 @@ module ts {
return undefined;
}
// Create a single instance that we can wrap the underlying emitter TextWriter with. That
// way we don't have to allocate a new wrapper every time writeTypeAtLocation and
// writeReturnTypeOfSignatureDeclaration are called.
var emitSymbolWriter = {
writer: <TextWriter>undefined,
writeKind: function (text: string) { this.writer.write(text) },
writeSymbol: function (text: string) { this.writer.write(text) },
writeLine: function () { this.writer.writeLine() },
increaseIndent: function () { this.writer.increaseIndent() },
decreaseIndent: function () { this.writer.decreaseIndent() },
clear: function () { },
trackSymbol: function (symbol: Symbol, declaration: Node, meaning: SymbolFlags) { this.writer.trackSymbol(symbol, declaration, meaning) }
};
function writeTypeAtLocation(location: Node, enclosingDeclaration: Node, flags: TypeFormatFlags, writer: TextWriter) {
function writeTypeAtLocation(location: Node, enclosingDeclaration: Node, flags: TypeFormatFlags, writer: SymbolWriter) {
// Get type of the symbol if this is the valid symbol otherwise get type at location
var symbol = getSymbolOfNode(location);
var type = symbol && !(symbol.flags & SymbolFlags.TypeLiteral) ? getTypeOfSymbol(symbol) : getTypeFromTypeNode(location);
emitSymbolWriter.writer = writer;
writeType(type, emitSymbolWriter, enclosingDeclaration, flags);
writeType(type, writer, enclosingDeclaration, flags);
}
function writeReturnTypeOfSignatureDeclaration(signatureDeclaration: SignatureDeclaration, enclosingDeclaration: Node, flags: TypeFormatFlags, writer: TextWriter) {
function writeReturnTypeOfSignatureDeclaration(signatureDeclaration: SignatureDeclaration, enclosingDeclaration: Node, flags: TypeFormatFlags, writer: SymbolWriter) {
var signature = getSignatureFromDeclaration(signatureDeclaration);
emitSymbolWriter.writer = writer;
writeType(getReturnTypeOfSignature(signature), emitSymbolWriter, enclosingDeclaration, flags);
writeType(getReturnTypeOfSignature(signature), writer, enclosingDeclaration, flags);
}
function invokeEmitter(targetSourceFile?: SourceFile) {
@@ -7705,49 +7610,4 @@ module ts {
return checker;
}
export function spacePart() {
return getSymbolDisplayPart(" ", SymbolDisplayPartKind.space, undefined);
}
export function keywordPart(kind: SyntaxKind) {
return getSymbolDisplayPart(tokenToString(kind), SymbolDisplayPartKind.keyword, undefined);
}
export function punctuationPart(kind: SyntaxKind) {
return getSymbolDisplayPart(tokenToString(kind), SymbolDisplayPartKind.punctuation, undefined);
}
export function operatorPart(kind: SyntaxKind) {
return getSymbolDisplayPart(tokenToString(kind), SymbolDisplayPartKind.operator, undefined);
}
export function textPart(text: string) {
return getSymbolDisplayPart(text, SymbolDisplayPartKind.text, undefined);
}
export function symbolPart(text: string, symbol: Symbol) {
return getSymbolDisplayPart(text, displayPartKind(symbol), symbol)
}
function displayPartKind(symbol: Symbol): SymbolDisplayPartKind {
var flags = symbol.flags;
if (flags & SymbolFlags.Variable) {
return symbol.declarations && symbol.declarations.length > 0 && symbol.declarations[0].kind === SyntaxKind.Parameter
? SymbolDisplayPartKind.parameterName
: SymbolDisplayPartKind.localName;
}
else if (flags & SymbolFlags.Property) { return SymbolDisplayPartKind.propertyName; }
else if (flags & SymbolFlags.EnumMember) { return SymbolDisplayPartKind.enumMemberName; }
else if (flags & SymbolFlags.Function) { return SymbolDisplayPartKind.functionName; }
else if (flags & SymbolFlags.Class) { return SymbolDisplayPartKind.className; }
else if (flags & SymbolFlags.Interface) { return SymbolDisplayPartKind.interfaceName; }
else if (flags & SymbolFlags.Enum) { return SymbolDisplayPartKind.enumName; }
else if (flags & SymbolFlags.Module) { return SymbolDisplayPartKind.moduleName; }
else if (flags & SymbolFlags.Method) { return SymbolDisplayPartKind.methodName; }
else if (flags & SymbolFlags.TypeParameter) { return SymbolDisplayPartKind.typeParameterName; }
return SymbolDisplayPartKind.text;
}
}
src/compiler/emitter.ts
+13 -2
View File
@@ -4,7 +4,9 @@
/// <reference path="parser.ts"/>
module ts {
interface EmitTextWriter extends TextWriter {
interface EmitTextWriter extends SymbolWriter {
write(s: string): void;
getText(): string;
rawWrite(s: string): void;
writeLiteral(s: string): void;
getTextPos(): number;
@@ -14,7 +16,7 @@ module ts {
}
var indentStrings: string[] = ["", " "];
function getIndentString(level: number) {
export function getIndentString(level: number) {
if (indentStrings[level] === undefined) {
indentStrings[level] = getIndentString(level - 1) + indentStrings[1];
}
@@ -147,9 +149,17 @@ module ts {
}
}
function writeKind(text: string, kind: SymbolDisplayPartKind) {
write(text);
}
function writeSymbol(text: string, symbol: Symbol) {
write(text);
}
return {
write: write,
trackSymbol: trackSymbol,
writeKind: writeKind,
writeSymbol: writeSymbol,
rawWrite: rawWrite,
writeLiteral: writeLiteral,
writeLine: writeLine,
@@ -160,6 +170,7 @@ module ts {
getLine: () => lineCount + 1,
getColumn: () => lineStart ? indent * getIndentSize() + 1 : output.length - linePos + 1,
getText: () => output,
clear: () => { }
};
}
src/compiler/types.ts
+13 -13
View File
@@ -643,9 +643,9 @@ module ts {
getTypeOfNode(node: Node): Type;
getApparentType(type: Type): ApparentType;
typeToString(type: Type, enclosingDeclaration?: Node, flags?: TypeFormatFlags): string;
writeType(type: Type, writer: SymbolWriter, enclosingDeclaration?: Node, flags?: TypeFormatFlags): void;
symbolToString(symbol: Symbol, enclosingDeclaration?: Node, meaning?: SymbolFlags): string;
typeToDisplayParts(type: Type, enclosingDeclaration?: Node, flags?: TypeFormatFlags): SymbolDisplayPart[];
symbolToDisplayParts(symbol: Symbol, enclosingDeclaration?: Node, meaning?: SymbolFlags): SymbolDisplayPart[];
writeSymbol(symbol: Symbol, writer: SymbolWriter, enclosingDeclaration?: Node, meaning?: SymbolFlags): void;
getFullyQualifiedName(symbol: Symbol): string;
getAugmentedPropertiesOfApparentType(type: Type): Symbol[];
getRootSymbol(symbol: Symbol): Symbol;
@@ -659,13 +659,18 @@ module ts {
isValidPropertyAccess(node: PropertyAccess, propertyName: string): boolean;
}
export interface TextWriter {
write(s: string): void;
trackSymbol(symbol: Symbol, enclosingDeclaration?: Node, meaning?: SymbolFlags): void;
export interface SymbolWriter {
writeKind(text: string, kind: SymbolDisplayPartKind): void;
writeSymbol(text: string, symbol: Symbol): void;
writeLine(): void;
increaseIndent(): void;
decreaseIndent(): void;
getText(): string;
clear(): void;
// Called when the symbol writer encounters a symbol to write. Currently only used by the
// declaration emitter to help determine if it should patch up the final declaration file
// with import statements it previously saw (but chose not to emit).
trackSymbol(symbol: Symbol, enclosingDeclaration?: Node, meaning?: SymbolFlags): void;
}
export enum TypeFormatFlags {
@@ -701,8 +706,8 @@ module ts {
hasSemanticErrors(): boolean;
isDeclarationVisible(node: Declaration): boolean;
isImplementationOfOverload(node: FunctionDeclaration): boolean;
writeTypeAtLocation(location: Node, enclosingDeclaration: Node, flags: TypeFormatFlags, writer: TextWriter): void;
writeReturnTypeOfSignatureDeclaration(signatureDeclaration: SignatureDeclaration, enclosingDeclaration: Node, flags: TypeFormatFlags, writer: TextWriter): void;
writeTypeAtLocation(location: Node, enclosingDeclaration: Node, flags: TypeFormatFlags, writer: SymbolWriter): void;
writeReturnTypeOfSignatureDeclaration(signatureDeclaration: SignatureDeclaration, enclosingDeclaration: Node, flags: TypeFormatFlags, writer: SymbolWriter): void;
isSymbolAccessible(symbol: Symbol, enclosingDeclaration: Node, meaning: SymbolFlags): SymbolAccessiblityResult;
isImportDeclarationEntityNameReferenceDeclarationVisibile(entityName: EntityName): SymbolAccessiblityResult;
@@ -1190,11 +1195,6 @@ module ts {
verticalTab = 0x0B, // \v
}
export interface SymbolDisplayPart {
text: string;
kind: SymbolDisplayPartKind;
}
export enum SymbolDisplayPartKind {
aliasName,
className,
src/services/services.ts
+149 -16
View File
@@ -252,7 +252,7 @@ module ts {
var docComments = getJsDocCommentsSeparatedByNewLines(this);
ts.forEach(docComments, docComment => {
if (this.documentationComment.length) {
this.documentationComment.push(getSymbolDisplayPart("\n", SymbolDisplayPartKind.lineBreak));
this.documentationComment.push(lineBreakPart());
}
this.documentationComment.push(docComment);
});
@@ -936,6 +936,11 @@ module ts {
containerKind: string;
containerName: string;
}
export interface SymbolDisplayPart {
text: string;
kind: SymbolDisplayPartKind;
}
export interface QuickInfo {
kind: string;
@@ -1227,6 +1232,133 @@ module ts {
});
return result;
}
interface DisplayPartsSymbolWriter extends SymbolWriter {
displayParts(): SymbolDisplayPart[];
}
var displayPartWriters: DisplayPartsSymbolWriter[] = [];
function getDisplayPartWriter(): DisplayPartsSymbolWriter {
if (displayPartWriters.length !== 0) {
return displayPartWriters.pop();
}
var displayParts: SymbolDisplayPart[] = [];
var lineStart = true;
var indent = 0;
return {
displayParts: () => displayParts,
writeKind: writeKind,
writeSymbol: writeSymbol,
writeLine: writeLine,
increaseIndent: () => { indent++; },
decreaseIndent: () => { indent--; },
clear: () => displayParts = [],
trackSymbol: () => { }
};
function writeIndent() {
if (lineStart) {
displayParts.push(displayPart(getIndentString(indent), SymbolDisplayPartKind.space));
lineStart = false;
}
}
function writeKind(text: string, kind: SymbolDisplayPartKind) {
writeIndent();
displayParts.push(displayPart(text, kind));
}
function writeSymbol(text: string, symbol: Symbol) {
writeIndent();
displayParts.push(symbolPart(text, symbol));
}
function writeLine() {
displayParts.push(lineBreakPart());
lineStart = true;
}
}
function releaseDisplayPartWriter(writer: DisplayPartsSymbolWriter) {
writer.clear();
displayPartWriters.push(writer);
}
function displayPart(text: string, kind: SymbolDisplayPartKind, symbol?: Symbol): SymbolDisplayPart {
return <SymbolDisplayPart> {
text: text,
kind: kind
};
}
export function spacePart() {
return displayPart(" ", SymbolDisplayPartKind.space);
}
export function keywordPart(kind: SyntaxKind) {
return displayPart(tokenToString(kind), SymbolDisplayPartKind.keyword);
}
export function punctuationPart(kind: SyntaxKind) {
return displayPart(tokenToString(kind), SymbolDisplayPartKind.punctuation);
}
export function operatorPart(kind: SyntaxKind) {
return displayPart(tokenToString(kind), SymbolDisplayPartKind.operator);
}
export function textPart(text: string) {
return displayPart(text, SymbolDisplayPartKind.text);
}
export function lineBreakPart() {
return displayPart("\n", SymbolDisplayPartKind.lineBreak);
}
export function symbolPart(text: string, symbol: Symbol) {
return displayPart(text, displayPartKind(symbol), symbol);
function displayPartKind(symbol: Symbol): SymbolDisplayPartKind {
var flags = symbol.flags;
if (flags & SymbolFlags.Variable) {
return symbol.declarations && symbol.declarations.length > 0 && symbol.declarations[0].kind === SyntaxKind.Parameter
? SymbolDisplayPartKind.parameterName
: SymbolDisplayPartKind.localName;
}
else if (flags & SymbolFlags.Property) { return SymbolDisplayPartKind.propertyName; }
else if (flags & SymbolFlags.EnumMember) { return SymbolDisplayPartKind.enumMemberName; }
else if (flags & SymbolFlags.Function) { return SymbolDisplayPartKind.functionName; }
else if (flags & SymbolFlags.Class) { return SymbolDisplayPartKind.className; }
else if (flags & SymbolFlags.Interface) { return SymbolDisplayPartKind.interfaceName; }
else if (flags & SymbolFlags.Enum) { return SymbolDisplayPartKind.enumName; }
else if (flags & SymbolFlags.Module) { return SymbolDisplayPartKind.moduleName; }
else if (flags & SymbolFlags.Method) { return SymbolDisplayPartKind.methodName; }
else if (flags & SymbolFlags.TypeParameter) { return SymbolDisplayPartKind.typeParameterName; }
return SymbolDisplayPartKind.text;
}
}
export function typeToDisplayParts(typechecker: TypeChecker, type: Type, enclosingDeclaration?: Node, flags?: TypeFormatFlags): SymbolDisplayPart[] {
var displayPartWriter = getDisplayPartWriter();
typechecker.writeType(type, displayPartWriter, enclosingDeclaration, flags);
var result = displayPartWriter.displayParts();
releaseDisplayPartWriter(displayPartWriter);
return result;
}
export function symbolToDisplayParts(typeChecker: TypeChecker, symbol: Symbol, enclosingDeclaration?: Node, meaning?: SymbolFlags): SymbolDisplayPart[] {
var displayPartWriter = getDisplayPartWriter();
typeChecker.writeSymbol(symbol, displayPartWriter, enclosingDeclaration, meaning);
var result = displayPartWriter.displayParts();
releaseDisplayPartWriter(displayPartWriter);
return result;
}
export function getDefaultCompilerOptions(): CompilerOptions {
// Set "ES5" target by default for language service
return {
@@ -2367,7 +2499,7 @@ module ts {
name: entryName,
kind: ScriptElementKind.keyword,
kindModifiers: ScriptElementKindModifier.none,
displayParts: [getSymbolDisplayPart(entryName, SymbolDisplayPartKind.keyword)],
displayParts: [displayPart(entryName, SymbolDisplayPartKind.keyword)],
documentation: undefined
};
}
@@ -2481,33 +2613,28 @@ module ts {
function getSymbolDisplayPartsofSymbol(symbol: Symbol, sourceFile: SourceFile, enclosingDeclaration: Node, typeResolver: TypeChecker): SymbolDisplayPart[] {
var displayParts: SymbolDisplayPart[] = [];
function addNewLineIfDisplayPartsExist() {
if (displayParts.length) {
displayParts.push(getSymbolDisplayPart("\n", SymbolDisplayPartKind.lineBreak));
}
}
if (symbol.flags & SymbolFlags.Class) {
displayParts.push(keywordPart(SyntaxKind.ClassKeyword));
displayParts.push(spacePart());
displayParts.push.apply(displayParts, typeResolver.symbolToDisplayParts(symbol, sourceFile));
displayParts.push.apply(displayParts, symbolToDisplayParts(typeResolver, symbol, sourceFile));
}
if (symbol.flags & SymbolFlags.Interface) {
addNewLineIfDisplayPartsExist();
displayParts.push(keywordPart(SyntaxKind.InterfaceKeyword));
displayParts.push(spacePart());
displayParts.push.apply(displayParts, typeResolver.symbolToDisplayParts(symbol, sourceFile));
displayParts.push.apply(displayParts, symbolToDisplayParts(typeResolver, symbol, sourceFile));
}
if (symbol.flags & SymbolFlags.Enum) {
addNewLineIfDisplayPartsExist();
displayParts.push(keywordPart(SyntaxKind.EnumKeyword));
displayParts.push(spacePart());
displayParts.push.apply(displayParts, typeResolver.symbolToDisplayParts(symbol, sourceFile));
displayParts.push.apply(displayParts, symbolToDisplayParts(typeResolver, symbol, sourceFile));
}
if (symbol.flags & SymbolFlags.Module) {
addNewLineIfDisplayPartsExist();
displayParts.push(keywordPart(SyntaxKind.ModuleKeyword));
displayParts.push(spacePart());
displayParts.push.apply(displayParts, typeResolver.symbolToDisplayParts(symbol, sourceFile));
displayParts.push.apply(displayParts, symbolToDisplayParts(typeResolver, symbol, sourceFile));
}
if (symbol.flags & SymbolFlags.TypeParameter) {
addNewLineIfDisplayPartsExist();
@@ -2515,7 +2642,7 @@ module ts {
displayParts.push(textPart("type parameter"));
displayParts.push(punctuationPart(SyntaxKind.CloseParenToken));
displayParts.push(spacePart());
displayParts.push.apply(displayParts, typeResolver.symbolToDisplayParts(symbol, enclosingDeclaration));
displayParts.push.apply(displayParts, symbolToDisplayParts(typeResolver, symbol, enclosingDeclaration));
}
else {
//public static string FormatSymbolName(string name, string fullSymbolName, string kind, out bool useTypeName)
@@ -2558,7 +2685,7 @@ module ts {
displayParts.push(punctuationPart(SyntaxKind.CloseParenToken));
displayParts.push(spacePart());
displayParts.push.apply(displayParts, typeResolver.symbolToDisplayParts(symbol, enclosingDeclaration));
displayParts.push.apply(displayParts, symbolToDisplayParts(typeResolver, symbol, sourceFile));
}
var type = typeResolver.getTypeOfSymbol(symbol);
@@ -2567,7 +2694,7 @@ module ts {
if (type) {
displayParts.push(punctuationPart(SyntaxKind.ColonToken));
displayParts.push(spacePart());
displayParts.push.apply(displayParts, typeResolver.typeToDisplayParts(type, enclosingDeclaration, TypeFormatFlags.NoTruncation));
displayParts.push.apply(displayParts, typeToDisplayParts(typeResolver, type, enclosingDeclaration, TypeFormatFlags.NoTruncation));
}
}
else if (symbol.flags & SymbolFlags.Function ||
@@ -2575,7 +2702,7 @@ module ts {
symbol.flags & SymbolFlags.Signature ||
symbol.flags & SymbolFlags.Accessor) {
if (type) {
displayParts.push.apply(displayParts, typeResolver.typeToDisplayParts(type, enclosingDeclaration, TypeFormatFlags.NoTruncation | TypeFormatFlags.NoArrowStyleTopLevelSignature));
displayParts.push.apply(displayParts, typeToDisplayParts(typeResolver, type, enclosingDeclaration, TypeFormatFlags.NoTruncation | TypeFormatFlags.NoArrowStyleTopLevelSignature));
}
}
else if (symbol.flags & SymbolFlags.EnumMember) {
@@ -2586,7 +2713,7 @@ module ts {
displayParts.push(spacePart());
displayParts.push(operatorPart(SyntaxKind.EqualsToken));
displayParts.push(spacePart());
displayParts.push(getSymbolDisplayPart(constantValue.toString(), SymbolDisplayPartKind.numericLiteral));
displayParts.push(displayPart(constantValue.toString(), SymbolDisplayPartKind.numericLiteral));
}
}
}
@@ -2594,6 +2721,12 @@ module ts {
}
return displayParts;
function addNewLineIfDisplayPartsExist() {
if (displayParts.length) {
displayParts.push(lineBreakPart());
}
}
}
function getQuickInfoAtPosition(fileName: string, position: number): QuickInfo {
src/services/signatureHelp.ts
+3 -3
View File
@@ -268,7 +268,7 @@ module ts.SignatureHelp {
displayParts.push(punctuationPart(SyntaxKind.ColonToken));
displayParts.push(spacePart());
var typeParts = typeInfoResolver.typeToDisplayParts(typeInfoResolver.getTypeOfSymbol(p), argumentListOrTypeArgumentList);
var typeParts = typeToDisplayParts(typeInfoResolver, typeInfoResolver.getTypeOfSymbol(p), argumentListOrTypeArgumentList);
displayParts.push.apply(displayParts, typeParts);
return {
@@ -282,7 +282,7 @@ module ts.SignatureHelp {
var callTargetNode = (<CallExpression>argumentListOrTypeArgumentList.parent).func;
var callTargetSymbol = typeInfoResolver.getSymbolInfo(callTargetNode);
var prefixParts = callTargetSymbol ? typeInfoResolver.symbolToDisplayParts(callTargetSymbol, /*enclosingDeclaration*/ undefined, /*meaning*/ undefined) : [];
var prefixParts = callTargetSymbol ? symbolToDisplayParts(typeInfoResolver, callTargetSymbol, /*enclosingDeclaration*/ undefined, /*meaning*/ undefined) : [];
var separatorParts = [punctuationPart(SyntaxKind.CommaToken), spacePart()];
@@ -308,7 +308,7 @@ module ts.SignatureHelp {
suffixParts.push(punctuationPart(SyntaxKind.ColonToken));
suffixParts.push(spacePart());
var typeParts = typeInfoResolver.typeToDisplayParts(candidateSignature.getReturnType(), argumentListOrTypeArgumentList);
var typeParts = typeToDisplayParts(typeInfoResolver, candidateSignature.getReturnType(), argumentListOrTypeArgumentList);
suffixParts.push.apply(suffixParts, typeParts);
return {