Merge pull request microsoft#708 from Microsoft/classifiedQuickInfo

Initial work on classified quick info.

Author: CyrusNajmabadi

src/compiler/checker.ts

@@ -101,7 +101,7 @@ module ts {
  };
  }
 
- function createTextWriter(writeSymbol: (symbol: Symbol, enclosingDeclaration?: Node, meaning?: SymbolFlags)=> void): EmitTextWriter {
+ function createTextWriter(trackSymbol: (symbol: Symbol, enclosingDeclaration?: Node, meaning?: SymbolFlags)=> void): EmitTextWriter {
  var output = "";
  var indent = 0;
  var lineStart = true;
@@ -149,7 +149,7 @@ module ts {
 
  return {
  write: write,
- writeSymbol: writeSymbol,
+ trackSymbol: trackSymbol,
  rawWrite: rawWrite,
  writeLiteral: writeLiteral,
  writeLine: writeLine,
@@ -182,7 +182,7 @@ module ts {
  });
  }
 
- function emitComments(comments: Comment[], trailingSeparator: boolean, writer: EmitTextWriter, writeComment: (comment: Comment, writer: EmitTextWriter) => void) {
+ function emitComments(comments: CommentRange[], trailingSeparator: boolean, writer: EmitTextWriter, writeComment: (comment: CommentRange, writer: EmitTextWriter) => void) {
  var emitLeadingSpace = !trailingSeparator;
  forEach(comments, comment => {
  if (emitLeadingSpace) {
@@ -203,15 +203,15 @@ module ts {
  });
  }
 
- function emitNewLineBeforeLeadingComments(node: TextRange, leadingComments: Comment[], writer: EmitTextWriter) {
+ function emitNewLineBeforeLeadingComments(node: TextRange, leadingComments: CommentRange[], writer: EmitTextWriter) {
  // If the leading comments start on different line than the start of node, write new line
  if (leadingComments && leadingComments.length && node.pos !== leadingComments[0].pos &&
  getLineOfLocalPosition(node.pos) !== getLineOfLocalPosition(leadingComments[0].pos)) {
  writer.writeLine();
  }
  }
 
- function writeCommentRange(comment: Comment, writer: EmitTextWriter) {
+ function writeCommentRange(comment: CommentRange, writer: EmitTextWriter) {
  if (currentSourceFile.text.charCodeAt(comment.pos + 1) === CharacterCodes.asterisk) {
  var firstCommentLineAndCharacter = currentSourceFile.getLineAndCharacterFromPosition(comment.pos);
  var firstCommentLineIndent: number;
@@ -307,7 +307,7 @@ module ts {
  }
 
  function emitJavaScript(jsFilePath: string, root?: SourceFile) {
- var writer = createTextWriter(writeSymbol);
+ var writer = createTextWriter(trackSymbol);
  var write = writer.write;
  var writeLine = writer.writeLine;
  var increaseIndent = writer.increaseIndent;
@@ -363,7 +363,7 @@ module ts {
  /** Sourcemap data that will get encoded */
  var sourceMapData: SourceMapData;
 
- function writeSymbol(symbol: Symbol, enclosingDeclaration: Node, meaning: SymbolFlags) { }
+ function trackSymbol(symbol: Symbol, enclosingDeclaration: Node, meaning: SymbolFlags) { }
 
  function initializeEmitterWithSourceMaps() {
  var sourceMapDir: string; // The directory in which sourcemap will be
@@ -585,7 +585,7 @@ module ts {
  sourceMapNameIndices.pop();
  };
 
- function writeCommentRangeWithMap(comment: Comment, writer: EmitTextWriter) {
+ function writeCommentRangeWithMap(comment: CommentRange, writer: EmitTextWriter) {
  recordSourceMapSpan(comment.pos);
  writeCommentRange(comment, writer);
  recordSourceMapSpan(comment.end);
@@ -916,14 +916,15 @@ module ts {
  }
 
  function emitPropertyAccess(node: PropertyAccess) {
- var text = resolver.getPropertyAccessSubstitution(node);
- if (text) {
- write(text);
- return;
+ var constantValue = resolver.getConstantValue(node);
+ if (constantValue !== undefined) {
+ write(constantValue.toString() + " /* " + identifierToString(node.right) + " */");
+ }
+ else {
+ emit(node.left);
+ write(".");
+ emit(node.right);
  }
- emit(node.left);
- write(".");
- emit(node.right);
  }
 
  function emitIndexedAccess(node: IndexedAccess) {
@@ -2155,7 +2156,7 @@ module ts {
 
  function getLeadingCommentsWithoutDetachedComments() {
  // get the leading comments from detachedPos
- var leadingComments = getLeadingComments(currentSourceFile.text, detachedCommentsInfo[detachedCommentsInfo.length - 1].detachedCommentEndPos);
+ var leadingComments = getLeadingCommentRanges(currentSourceFile.text, detachedCommentsInfo[detachedCommentsInfo.length - 1].detachedCommentEndPos);
  if (detachedCommentsInfo.length - 1) {
  detachedCommentsInfo.pop();
  }
@@ -2169,14 +2170,14 @@ module ts {
  function getLeadingCommentsToEmit(node: Node) {
  // Emit the leading comments only if the parent's pos doesn't match because parent should take care of emitting these comments
  if (node.parent.kind === SyntaxKind.SourceFile || node.pos !== node.parent.pos) {
- var leadingComments: Comment[];
+ var leadingComments: CommentRange[];
  if (hasDetachedComments(node.pos)) {
  // get comments without detached comments
  leadingComments = getLeadingCommentsWithoutDetachedComments();
  }
  else {
  // get the leading comments from the node
- leadingComments = getLeadingCommentsOfNode(node, currentSourceFile);
+ leadingComments = getLeadingCommentRangesOfNode(node, currentSourceFile);
  }
  return leadingComments;
  }
@@ -2192,32 +2193,32 @@ module ts {
  function emitTrailingDeclarationComments(node: Node) {
  // Emit the trailing comments only if the parent's end doesn't match
  if (node.parent.kind === SyntaxKind.SourceFile || node.end !== node.parent.end) {
- var trailingComments = getTrailingComments(currentSourceFile.text, node.end);
+ var trailingComments = getTrailingCommentRanges(currentSourceFile.text, node.end);
  // trailing comments are emitted at space/*trailing comment1 */space/*trailing comment*/
  emitComments(trailingComments, /*trailingSeparator*/ false, writer, writeComment);
  }
  }
 
  function emitLeadingCommentsOfLocalPosition(pos: number) {
- var leadingComments: Comment[];
+ var leadingComments: CommentRange[];
  if (hasDetachedComments(pos)) {
  // get comments without detached comments
  leadingComments = getLeadingCommentsWithoutDetachedComments();
  }
  else {
  // get the leading comments from the node
- leadingComments = getLeadingComments(currentSourceFile.text, pos);
+ leadingComments = getLeadingCommentRanges(currentSourceFile.text, pos);
  }
  emitNewLineBeforeLeadingComments({ pos: pos, end: pos }, leadingComments, writer);
  // Leading comments are emitted at /*leading comment1 */space/*leading comment*/space
  emitComments(leadingComments, /*trailingSeparator*/ true, writer, writeComment);
  }
 
  function emitDetachedCommentsAtPosition(node: TextRange) {
- var leadingComments = getLeadingComments(currentSourceFile.text, node.pos);
+ var leadingComments = getLeadingCommentRanges(currentSourceFile.text, node.pos);
  if (leadingComments) {
- var detachedComments: Comment[] = [];
- var lastComment: Comment;
+ var detachedComments: CommentRange[] = [];
+ var lastComment: CommentRange;
 
  forEach(leadingComments, comment => {
  if (lastComment) {
@@ -2261,7 +2262,7 @@ module ts {
  function emitPinnedOrTripleSlashCommentsOfNode(node: Node) {
  var pinnedComments = ts.filter(getLeadingCommentsToEmit(node), isPinnedOrTripleSlashComment);
 
- function isPinnedOrTripleSlashComment(comment: Comment) {
+ function isPinnedOrTripleSlashComment(comment: CommentRange) {
  if (currentSourceFile.text.charCodeAt(comment.pos + 1) === CharacterCodes.asterisk) {
  return currentSourceFile.text.charCodeAt(comment.pos + 2) === CharacterCodes.exclamation;
  }
@@ -2300,7 +2301,7 @@ module ts {
  }
 
  function emitDeclarations(jsFilePath: string, root?: SourceFile) {
- var writer = createTextWriter(writeSymbol);
+ var writer = createTextWriter(trackSymbol);
  var write = writer.write;
  var writeLine = writer.writeLine;
  var increaseIndent = writer.increaseIndent;
@@ -2328,7 +2329,7 @@ module ts {
  var oldWriter = writer;
  forEach(importDeclarations, aliasToWrite => {
  var aliasEmitInfo = forEach(aliasDeclarationEmitInfo, declEmitInfo => declEmitInfo.declaration === aliasToWrite ? declEmitInfo : undefined);
- writer = createTextWriter(writeSymbol);
+ writer = createTextWriter(trackSymbol);
  for (var declarationIndent = aliasEmitInfo.indent; declarationIndent; declarationIndent--) {
  writer.increaseIndent();
  }
@@ -2339,10 +2340,9 @@ module ts {
  writer = oldWriter;
  }
 
- function writeSymbol(symbol: Symbol, enclosingDeclaration?: Node, meaning?: SymbolFlags) {
+ function trackSymbol(symbol: Symbol, enclosingDeclaration?: Node, meaning?: SymbolFlags) {
  var symbolAccesibilityResult = resolver.isSymbolAccessible(symbol, enclosingDeclaration, meaning);
  if (symbolAccesibilityResult.accessibility === SymbolAccessibility.Accessible) {
- resolver.writeSymbol(symbol, enclosingDeclaration, meaning, writer);
 
  // write the aliases
  if (symbolAccesibilityResult && symbolAccesibilityResult.aliasesToMakeVisible) {

src/compiler/emitter.ts

@@ -138,25 +138,27 @@ module ts {
  return (<Identifier>(<ExpressionStatement>node).expression).text === "use strict";
  }
 
- export function getLeadingCommentsOfNode(node: Node, sourceFileOfNode: SourceFile) {
+ export function getLeadingCommentRangesOfNode(node: Node, sourceFileOfNode?: SourceFile) {
+ sourceFileOfNode = sourceFileOfNode || getSourceFileOfNode(node);
+
  // If parameter/type parameter, the prev token trailing comments are part of this node too
  if (node.kind === SyntaxKind.Parameter || node.kind === SyntaxKind.TypeParameter) {
  // e.g. (/** blah */ a, /** blah */ b);
- return concatenate(getTrailingComments(sourceFileOfNode.text, node.pos),
+ return concatenate(getTrailingCommentRanges(sourceFileOfNode.text, node.pos),
  // e.g.: (
  // /** blah */ a,
  // /** blah */ b);
- getLeadingComments(sourceFileOfNode.text, node.pos));
+ getLeadingCommentRanges(sourceFileOfNode.text, node.pos));
  }
  else {
- return getLeadingComments(sourceFileOfNode.text, node.pos);
+ return getLeadingCommentRanges(sourceFileOfNode.text, node.pos);
  }
  }
 
  export function getJsDocComments(node: Declaration, sourceFileOfNode: SourceFile) {
- return filter(getLeadingCommentsOfNode(node, sourceFileOfNode), comment => isJsDocComment(comment));
+ return filter(getLeadingCommentRangesOfNode(node, sourceFileOfNode), comment => isJsDocComment(comment));
 
- function isJsDocComment(comment: Comment) {
+ function isJsDocComment(comment: CommentRange) {
  // True if the comment starts with '/**' but not if it is '/**/'
  return sourceFileOfNode.text.charCodeAt(comment.pos + 1) === CharacterCodes.asterisk &&
  sourceFileOfNode.text.charCodeAt(comment.pos + 2) === CharacterCodes.asterisk &&

src/compiler/parser.ts

@@ -371,8 +371,8 @@ module ts {
  // between the given position and the next line break are returned. The return value is an array containing a TextRange for each
  // comment. Single-line comment ranges include the beginning '//' characters but not the ending line break. Multi-line comment
  // ranges include the beginning '/* and ending '*/' characters. The return value is undefined if no comments were found.
- function getCommentRanges(text: string, pos: number, trailing: boolean): Comment[] {
- var result: Comment[];
+ function getCommentRanges(text: string, pos: number, trailing: boolean): CommentRange[] {
+ var result: CommentRange[];
  var collecting = trailing || pos === 0;
  while (true) {
  var ch = text.charCodeAt(pos);
@@ -440,11 +440,11 @@ module ts {
  }
  }
 
- export function getLeadingComments(text: string, pos: number): Comment[] {
+ export function getLeadingCommentRanges(text: string, pos: number): CommentRange[] {
  return getCommentRanges(text, pos, /*trailing*/ false);
  }
 
- export function getTrailingComments(text: string, pos: number): Comment[] {
+ export function getTrailingCommentRanges(text: string, pos: number): CommentRange[] {
  return getCommentRanges(text, pos, /*trailing*/ true);
  }
 

src/compiler/scanner.ts

@@ -529,7 +529,7 @@ module ts {
  filename: string;
  }
 
- export interface Comment extends TextRange {
+ export interface CommentRange extends TextRange {
  hasTrailingNewLine?: boolean;
  }
 
@@ -640,15 +640,21 @@ module ts {
  getApparentType(type: Type): ApparentType;
  typeToString(type: Type, enclosingDeclaration?: Node, flags?: TypeFormatFlags): string;
  symbolToString(symbol: Symbol, enclosingDeclaration?: Node, meaning?: SymbolFlags): string;
+ typeToDisplayParts(type: Type, enclosingDeclaration?: Node, flags?: TypeFormatFlags): SymbolDisplayPart[];
+ symbolToDisplayParts(symbol: Symbol, enclosingDeclaration?: Node, meaning?: SymbolFlags): SymbolDisplayPart[];
  getFullyQualifiedName(symbol: Symbol): string;
  getAugmentedPropertiesOfApparentType(type: Type): Symbol[];
  getRootSymbol(symbol: Symbol): Symbol;
  getContextualType(node: Node): Type;
+
+ // Returns the constant value of this enum member, or 'undefined' if the enum member has a 
+ // computed value.
+ getEnumMemberValue(node: EnumMember): number;
  }
 
  export interface TextWriter {
  write(s: string): void;
- writeSymbol(symbol: Symbol, enclosingDeclaration?: Node, meaning?: SymbolFlags): void;
+ trackSymbol(symbol: Symbol, enclosingDeclaration?: Node, meaning?: SymbolFlags): void;
  writeLine(): void;
  increaseIndent(): void;
  decreaseIndent(): void;
@@ -679,7 +685,6 @@ module ts {
  getProgram(): Program;
  getLocalNameOfContainer(container: Declaration): string;
  getExpressionNamePrefix(node: Identifier): string;
- getPropertyAccessSubstitution(node: PropertyAccess): string;
  getExportAssignmentName(node: SourceFile): string;
  isReferencedImportDeclaration(node: ImportDeclaration): boolean;
  isTopLevelValueImportedViaEntityName(node: ImportDeclaration): boolean;
@@ -690,9 +695,12 @@ module ts {
  isImplementationOfOverload(node: FunctionDeclaration): boolean;
  writeTypeAtLocation(location: Node, enclosingDeclaration: Node, flags: TypeFormatFlags, writer: TextWriter): void;
  writeReturnTypeOfSignatureDeclaration(signatureDeclaration: SignatureDeclaration, enclosingDeclaration: Node, flags: TypeFormatFlags, writer: TextWriter): void;
- writeSymbol(symbol: Symbol, enclosingDeclaration: Node, meaning: SymbolFlags, writer: TextWriter): void;
  isSymbolAccessible(symbol: Symbol, enclosingDeclaration: Node, meaning: SymbolFlags): SymbolAccessiblityResult;
  isImportDeclarationEntityNameReferenceDeclarationVisibile(entityName: EntityName): SymbolAccessiblityResult;
+
+ // Returns the constant value this property access resolves to, or 'undefined' if it does 
+ // resolve to a constant.
+ getConstantValue(node: PropertyAccess): number;
  }
 
  export enum SymbolFlags {
@@ -794,13 +802,16 @@ module ts {
  }
 
  export enum NodeCheckFlags {
- TypeChecked = 0x00000001, // Node has been type checked
- LexicalThis = 0x00000002, // Lexical 'this' reference
- CaptureThis = 0x00000004, // Lexical 'this' used in body
- EmitExtends = 0x00000008, // Emit __extends
- SuperInstance = 0x00000010, // Instance 'super' reference
- SuperStatic = 0x00000020, // Static 'super' reference
- ContextChecked = 0x00000040, // Contextual types have been assigned
+ TypeChecked = 0x00000001, // Node has been type checked
+ LexicalThis = 0x00000002, // Lexical 'this' reference
+ CaptureThis = 0x00000004, // Lexical 'this' used in body
+ EmitExtends = 0x00000008, // Emit __extends
+ SuperInstance = 0x00000010, // Instance 'super' reference
+ SuperStatic = 0x00000020, // Static 'super' reference
+ ContextChecked = 0x00000040, // Contextual types have been assigned
+
+ // Values for enum members have been computed, and any errors have been reported for them.
+ EnumValuesComputed = 0x00000080,
  }
 
  export interface NodeLinks {
@@ -1171,6 +1182,48 @@ module ts {
  verticalTab = 0x0B, // \v
  }
 
+ export class SymbolDisplayPart {
+ constructor(public text: string,
+ public kind: SymbolDisplayPartKind,
+ public symbol: Symbol) {
+ }
+
+ public toJSON() {
+ return {
+ text: this.text,
+ kind: SymbolDisplayPartKind[this.kind]
+ };
+ }
+ }
+
+ export enum SymbolDisplayPartKind {
+ aliasName,
+ className,
+ enumName,
+ fieldName,
+ interfaceName,
+ keyword,
+ labelName,
+ lineBreak,
+ numericLiteral,
+ stringLiteral,
+ localName,
+ methodName,
+ moduleName,
+ namespaceName,
+ operator,
+ parameterName,
+ propertyName,
+ punctuation,
+ space,
+ anonymousTypeIndicator,
+ text,
+ typeParameterName,
+ enumMemberName,
+ functionName,
+ regularExpressionLiteral,
+ }
+
  export interface CancellationToken {
  isCancellationRequested(): boolean;
  }