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

Merge branch 'master' into reportDeclarationEmitErrors

Browse source
This commit is contained in:
Yui T 2014-09-18 14:08:26 -07:00
parent c91c52de39 7aac8d5161
commit 3721382933
104 changed files with 768 additions and 440 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

85
src/compiler/checker.ts
View file

@ -65,7 +65,8 @@ module ts {
symbolToString: symbolToString,
getAugmentedPropertiesOfApparentType: getAugmentedPropertiesOfApparentType,
getRootSymbol: getRootSymbol,
getContextualType: getContextualType
getContextualType: getContextualType,
getFullyQualifiedName: getFullyQualifiedName
};
var undefinedSymbol = createSymbol(SymbolFlags.Property | SymbolFlags.Transient, "undefined");
@ -2431,7 +2432,7 @@ module ts {
case SyntaxKind.Identifier:
case SyntaxKind.QualifiedName:
var symbol = getSymbolInfo(node);
return getDeclaredTypeOfSymbol(symbol);
return symbol && getDeclaredTypeOfSymbol(symbol);
default:
return unknownType;
}
@ -3471,41 +3472,6 @@ module ts {
return getAncestor(node, kind) !== undefined;
}
function getAncestor(node: Node, kind: SyntaxKind): Node {
switch (kind) {
// special-cases that can be come first
case SyntaxKind.ClassDeclaration:
while (node) {
switch (node.kind) {
case SyntaxKind.ClassDeclaration:
return <ClassDeclaration>node;
case SyntaxKind.EnumDeclaration:
case SyntaxKind.InterfaceDeclaration:
case SyntaxKind.ModuleDeclaration:
case SyntaxKind.ImportDeclaration:
// early exit cases - declarations cannot be nested in classes
return undefined;
default:
node = node.parent;
continue;
}
}
break;
default:
while (node) {
if (node.kind === kind) {
return node;
}
else {
node = node.parent;
}
}
break;
}
return undefined;
}
// EXPRESSION TYPE CHECKING
function checkIdentifier(node: Identifier): Type {
@ -3852,6 +3818,11 @@ module ts {
// Return the contextual type for a given expression node. During overload resolution, a contextual type may temporarily
// be "pushed" onto a node using the contextualType property.
function getContextualType(node: Expression): Type {
if (isInsideWithStatementBody(node)) {
// We cannot answer semantic questions within a with block, do not proceed any further
return undefined;
}
if (node.contextualType) {
return node.contextualType;
}
@ -6717,7 +6688,20 @@ module ts {
return findChildAtPosition(sourceFile);
}
function getSymbolsInScope(location: Node, meaning: SymbolFlags): Symbol[] {
function isInsideWithStatementBody(node: Node): boolean {
if (node) {
while (node.parent) {
if (node.parent.kind === SyntaxKind.WithStatement && (<WithStatement>node.parent).statement === node) {
return true;
}
node = node.parent;
}
}
return false;
}
function getSymbolsInScope(location: Node, meaning: SymbolFlags): Symbol[]{
var symbols: SymbolTable = {};
var memberFlags: NodeFlags = 0;
function copySymbol(symbol: Symbol, meaning: SymbolFlags) {
@ -6737,6 +6721,12 @@ module ts {
}
}
}
if (isInsideWithStatementBody(location)) {
// We cannot answer semantic questions within a with block, do not proceed any further
return [];
}
while (location) {
if (location.locals && !isGlobalSourceFile(location)) {
copySymbols(location.locals, meaning);
@ -7009,6 +6999,11 @@ module ts {
}
function getSymbolInfo(node: Node) {
if (isInsideWithStatementBody(node)) {
// We cannot answer semantic questions within a with block, do not proceed any further
return undefined;
}
if (isDeclarationOrFunctionExpressionOrCatchVariableName(node)) {
// This is a declaration, call getSymbolOfNode
return getSymbolOfNode(node.parent);
@ -7063,9 +7058,15 @@ module ts {
}
function getTypeOfNode(node: Node): Type {
if (isInsideWithStatementBody(node)) {
// We cannot answer semantic questions within a with block, do not proceed any further
return unknownType;
}
if (isExpression(node)) {
return getTypeOfExpression(<Expression>node);
}
if (isTypeNode(node)) {
return getTypeFromTypeNode(<TypeNode>node);
}
@ -7078,7 +7079,7 @@ module ts {
if (isTypeDeclarationName(node)) {
var symbol = getSymbolInfo(node);
return getDeclaredTypeOfSymbol(symbol);
return symbol && getDeclaredTypeOfSymbol(symbol);
}
if (isDeclaration(node)) {
@ -7089,12 +7090,12 @@ module ts {
if (isDeclarationOrFunctionExpressionOrCatchVariableName(node)) {
var symbol = getSymbolInfo(node);
return getTypeOfSymbol(symbol);
return symbol && getTypeOfSymbol(symbol);
}
if (isInRightSideOfImportOrExportAssignment(node)) {
var symbol = getSymbolInfo(node);
var declaredType = getDeclaredTypeOfSymbol(symbol);
var declaredType = symbol && getDeclaredTypeOfSymbol(symbol);
return declaredType !== unknownType ? declaredType : getTypeOfSymbol(symbol);
}
@ -7146,7 +7147,7 @@ module ts {
}
function getRootSymbol(symbol: Symbol) {
return (symbol.flags & SymbolFlags.Transient) ? getSymbolLinks(symbol).target : symbol;
return ((symbol.flags & SymbolFlags.Transient) && getSymbolLinks(symbol).target) || symbol;
}
// Emitter support

65
src/compiler/parser.ts
View file

@ -531,6 +531,39 @@ module ts {
return false;
}
export function getAncestor(node: Node, kind: SyntaxKind): Node {
switch (kind) {
// special-cases that can be come first
case SyntaxKind.ClassDeclaration:
while (node) {
switch (node.kind) {
case SyntaxKind.ClassDeclaration:
return <ClassDeclaration>node;
case SyntaxKind.EnumDeclaration:
case SyntaxKind.InterfaceDeclaration:
case SyntaxKind.ModuleDeclaration:
case SyntaxKind.ImportDeclaration:
// early exit cases - declarations cannot be nested in classes
return undefined;
default:
node = node.parent;
continue;
}
}
break;
default:
while (node) {
if (node.kind === kind) {
return node;
}
node = node.parent;
}
break;
}
return undefined;
}
enum ParsingContext {
SourceElements, // Elements in source file
ModuleElements, // Elements in module declaration
@ -2200,10 +2233,38 @@ module ts {
function parseCallAndAccess(expr: Expression, inNewExpression: boolean): Expression {
while (true) {
var dotStart = scanner.getTokenPos();
if (parseOptional(SyntaxKind.DotToken)) {
var propertyAccess = <PropertyAccess>createNode(SyntaxKind.PropertyAccess, expr.pos);
// Technically a keyword is valid here as all keywords are identifier names.
// However, often we'll encounter this in error situations when the keyword
// is actually starting another valid construct.
//
// So, we check for the following specific case:
//
// name.
// keyword identifierNameOrKeyword
//
// Note: the newlines are important here. For example, if that above code
// were rewritten into:
//
// name.keyword
// identifierNameOrKeyword
//
// Then we would consider it valid. That's because ASI would take effect and
// the code would be implicitly: "name.keyword; identifierNameOrKeyword".
// In the first case though, ASI will not take effect because there is not a
// line terminator after the keyword.
if (scanner.hasPrecedingLineBreak() && scanner.isReservedWord() && lookAhead(() => scanner.isReservedWord())) {
grammarErrorAtPos(dotStart, scanner.getStartPos() - dotStart, Diagnostics.Identifier_expected);
var id = <Identifier>createMissingNode();
}
else {
var id = parseIdentifierName();
}
propertyAccess.left = expr;
propertyAccess.right = parseIdentifierName();
propertyAccess.right = id;
expr = finishNode(propertyAccess);
continue;
}
@ -3754,7 +3815,7 @@ module ts {
: undefined);
}
scanner = createScanner(languageVersion, sourceText, scanError, onComment);
scanner = createScanner(languageVersion, /*skipTrivia*/ true, sourceText, scanError, onComment);
var rootNodeFlags: NodeFlags = 0;
if (fileExtensionIs(filename, ".d.ts")) {
rootNodeFlags = NodeFlags.DeclarationFile;

35
src/compiler/scanner.ts
View file

@ -460,7 +460,7 @@ module ts {
ch > CharacterCodes.maxAsciiCharacter && isUnicodeIdentifierPart(ch, languageVersion);
}
export function createScanner(languageVersion: ScriptTarget, text?: string, onError?: ErrorCallback, onComment?: CommentCallback): Scanner {
export function createScanner(languageVersion: ScriptTarget, skipTrivia: boolean, text?: string, onError?: ErrorCallback, onComment?: CommentCallback): Scanner {
var pos: number; // Current position (end position of text of current token)
var len: number; // Length of text
var startPos: number; // Start position of whitespace before current token
@ -694,12 +694,34 @@ module ts {
case CharacterCodes.lineFeed:
case CharacterCodes.carriageReturn:
precedingLineBreak = true;
if (skipTrivia) {
pos++;
continue;
}
else {
if (ch === CharacterCodes.carriageReturn && pos + 1 < len && text.charCodeAt(pos + 1) === CharacterCodes.lineFeed) {
// consume both CR and LF
pos += 2;
}
else {
pos++;
}
return token = SyntaxKind.NewLineTrivia;
}
case CharacterCodes.tab:
case CharacterCodes.verticalTab:
case CharacterCodes.formFeed:
case CharacterCodes.space:
if (skipTrivia) {
pos++;
continue;
}
else {
while (pos < len && isWhiteSpace(text.charCodeAt(pos))) {
pos++;
}
return token = SyntaxKind.WhitespaceTrivia;
}
case CharacterCodes.exclamation:
if (text.charCodeAt(pos + 1) === CharacterCodes.equals) {
if (text.charCodeAt(pos + 2) === CharacterCodes.equals) {
@ -776,8 +798,14 @@ module ts {
if (onComment) {
onComment(tokenPos, pos);
}
if (skipTrivia) {
continue;
}
else {
return token = SyntaxKind.SingleLineCommentTrivia;
}
}
// Multi-line comment
if (text.charCodeAt(pos + 1) === CharacterCodes.asterisk) {
pos += 2;
@ -806,8 +834,13 @@ module ts {
onComment(tokenPos, pos);
}
if (skipTrivia) {
continue;
}
else {
return token = SyntaxKind.MultiLineCommentTrivia;
}
}
if (text.charCodeAt(pos + 1) === CharacterCodes.equals) {
return pos += 2, token = SyntaxKind.SlashEqualsToken;

5
src/compiler/types.ts
View file

@ -12,6 +12,10 @@ module ts {
export enum SyntaxKind {
Unknown,
EndOfFileToken,
SingleLineCommentTrivia,
MultiLineCommentTrivia,
NewLineTrivia,
WhitespaceTrivia,
// Literals
NumericLiteral,
StringLiteral,
@ -634,6 +638,7 @@ module ts {
getApparentType(type: Type): ApparentType;
typeToString(type: Type, enclosingDeclaration?: Node, flags?: TypeFormatFlags): string;
symbolToString(symbol: Symbol, enclosingDeclaration?: Node, meaning?: SymbolFlags): string;
getFullyQualifiedName(symbol: Symbol): string;
getAugmentedPropertiesOfApparentType(type: Type): Symbol[];
getRootSymbol(symbol: Symbol): Symbol;
getContextualType(node: Node): Type;

38
src/harness/fourslash.ts
View file

@ -898,6 +898,44 @@ module FourSlash {
}
}
private validate(name: string, expected: string, actual: string) {
if (expected && expected !== actual) {
throw new Error("Expected " + name + " '" + expected + "'. Got '" + actual + "' instead.");
}
}
public verifyRenameInfoSucceeded(displayName?: string, fullDisplayName?: string, kind?: string, kindModifiers?: string) {
var renameInfo = this.languageService.getRenameInfo(this.activeFile.fileName, this.currentCaretPosition);
if (!renameInfo.canRename) {
throw new Error("Rename did not succeed");
}
this.validate("displayName", displayName, renameInfo.displayName);
this.validate("fullDisplayName", fullDisplayName, renameInfo.fullDisplayName);
this.validate("kind", kind, renameInfo.kind);
this.validate("kindModifiers", kindModifiers, renameInfo.kindModifiers);
if (this.getRanges().length !== 1) {
throw new Error("Expected a single range to be selected in the test file.");
}
var expectedRange = this.getRanges()[0];
if (renameInfo.triggerSpan.start() !== expectedRange.start ||
renameInfo.triggerSpan.end() !== expectedRange.end) {
throw new Error("Expected triggerSpan [" + expectedRange.start + "," + expectedRange.end + "). Got [" +
renameInfo.triggerSpan.start() + "," + renameInfo.triggerSpan.end() + ") instead.");
}
}
public verifyRenameInfoFailed(message?: string) {
var renameInfo = this.languageService.getRenameInfo(this.activeFile.fileName, this.currentCaretPosition);
if (renameInfo.canRename) {
throw new Error("Rename was expected to fail");
}
this.validate("error", message, renameInfo.localizedErrorMessage);
}
//private getFormalParameter() {
// var help = this.languageService.getSignatureHelpItems(this.activeFile.fileName, this.currentCaretPosition);
// return help.formal;

32
src/lib/extensions.d.ts vendored
View file

@ -63,14 +63,14 @@ interface Int8Array extends ArrayBufferView {
/**
* Sets a value or an array of values.
* @param A typed or untyped array of values to set.
* @param array A typed or untyped array of values to set.
* @param offset The index in the current array at which the values are to be written.
*/
set(array: Int8Array, offset?: number): void;
/**
* Sets a value or an array of values.
* @param A typed or untyped array of values to set.
* @param array A typed or untyped array of values to set.
* @param offset The index in the current array at which the values are to be written.
*/
set(array: number[], offset?: number): void;
@ -121,14 +121,14 @@ interface Uint8Array extends ArrayBufferView {
/**
* Sets a value or an array of values.
* @param A typed or untyped array of values to set.
* @param array A typed or untyped array of values to set.
* @param offset The index in the current array at which the values are to be written.
*/
set(array: Uint8Array, offset?: number): void;
/**
* Sets a value or an array of values.
* @param A typed or untyped array of values to set.
* @param array A typed or untyped array of values to set.
* @param offset The index in the current array at which the values are to be written.
*/
set(array: number[], offset?: number): void;
@ -179,14 +179,14 @@ interface Int16Array extends ArrayBufferView {
/**
* Sets a value or an array of values.
* @param A typed or untyped array of values to set.
* @param array A typed or untyped array of values to set.
* @param offset The index in the current array at which the values are to be written.
*/
set(array: Int16Array, offset?: number): void;
/**
* Sets a value or an array of values.
* @param A typed or untyped array of values to set.
* @param array A typed or untyped array of values to set.
* @param offset The index in the current array at which the values are to be written.
*/
set(array: number[], offset?: number): void;
@ -237,14 +237,14 @@ interface Uint16Array extends ArrayBufferView {
/**
* Sets a value or an array of values.
* @param A typed or untyped array of values to set.
* @param array A typed or untyped array of values to set.
* @param offset The index in the current array at which the values are to be written.
*/
set(array: Uint16Array, offset?: number): void;
/**
* Sets a value or an array of values.
* @param A typed or untyped array of values to set.
* @param array A typed or untyped array of values to set.
* @param offset The index in the current array at which the values are to be written.
*/
set(array: number[], offset?: number): void;
@ -295,14 +295,14 @@ interface Int32Array extends ArrayBufferView {
/**
* Sets a value or an array of values.
* @param A typed or untyped array of values to set.
* @param array A typed or untyped array of values to set.
* @param offset The index in the current array at which the values are to be written.
*/
set(array: Int32Array, offset?: number): void;
/**
* Sets a value or an array of values.
* @param A typed or untyped array of values to set.
* @param array A typed or untyped array of values to set.
* @param offset The index in the current array at which the values are to be written.
*/
set(array: number[], offset?: number): void;
@ -353,14 +353,14 @@ interface Uint32Array extends ArrayBufferView {
/**
* Sets a value or an array of values.
* @param A typed or untyped array of values to set.
* @param array A typed or untyped array of values to set.
* @param offset The index in the current array at which the values are to be written.
*/
set(array: Uint32Array, offset?: number): void;
/**
* Sets a value or an array of values.
* @param A typed or untyped array of values to set.
* @param array A typed or untyped array of values to set.
* @param offset The index in the current array at which the values are to be written.
*/
set(array: number[], offset?: number): void;
@ -411,14 +411,14 @@ interface Float32Array extends ArrayBufferView {
/**
* Sets a value or an array of values.
* @param A typed or untyped array of values to set.
* @param array A typed or untyped array of values to set.
* @param offset The index in the current array at which the values are to be written.
*/
set(array: Float32Array, offset?: number): void;
/**
* Sets a value or an array of values.
* @param A typed or untyped array of values to set.
* @param array A typed or untyped array of values to set.
* @param offset The index in the current array at which the values are to be written.
*/
set(array: number[], offset?: number): void;
@ -469,14 +469,14 @@ interface Float64Array extends ArrayBufferView {
/**
* Sets a value or an array of values.
* @param A typed or untyped array of values to set.
* @param array A typed or untyped array of values to set.
* @param offset The index in the current array at which the values are to be written.
*/
set(array: Float64Array, offset?: number): void;
/**
* Sets a value or an array of values.
* @param A typed or untyped array of values to set.
* @param array A typed or untyped array of values to set.
* @param offset The index in the current array at which the values are to be written.
*/
set(array: number[], offset?: number): void;

364
src/services/services.ts
View file

@ -75,7 +75,7 @@ module ts {
update(scriptSnapshot: TypeScript.IScriptSnapshot, version: string, isOpen: boolean, textChangeRange: TypeScript.TextChangeRange): SourceFile;
}
var scanner: Scanner = createScanner(ScriptTarget.ES5);
var scanner: Scanner = createScanner(ScriptTarget.ES5, /*skipTrivia*/ true);
var emptyArray: any[] = [];
@ -770,7 +770,6 @@ module ts {
InMultiLineCommentTrivia,
InSingleQuoteStringLiteral,
InDoubleQuoteStringLiteral,
EndingWithDotToken,
}
export enum TokenClass {
@ -1684,14 +1683,20 @@ module ts {
/// Completion
function getValidCompletionEntryDisplayName(displayName: string, target: ScriptTarget): string {
if (displayName && displayName.length > 0) {
var firstChar = displayName.charCodeAt(0);
if (firstChar === TypeScript.CharacterCodes.singleQuote || firstChar === TypeScript.CharacterCodes.doubleQuote) {
var firstCharCode = displayName.charCodeAt(0);
if (displayName && displayName.length >= 2 && firstCharCode === displayName.charCodeAt(displayName.length - 1) &&
(firstCharCode === CharacterCodes.singleQuote || firstCharCode === CharacterCodes.doubleQuote)) {
// If the user entered name for the symbol was quoted, removing the quotes is not enough, as the name could be an
// invalid identifier name. We need to check if whatever was inside the quotes is actually a valid identifier name.
displayName = TypeScript.stripStartAndEndQuotes(displayName);
// invalid identifer name. We need to check if whatever was inside the quotes is actually a valid identifier name.
displayName = displayName.substring(1, displayName.length - 1);
}
if (TypeScript.Scanner.isValidIdentifier(TypeScript.SimpleText.fromString(displayName), target)) {
var isValid = isIdentifierStart(displayName.charCodeAt(0), target);
for (var i = 1, n = displayName.length; isValid && i < n; i++) {
isValid = isIdentifierPart(displayName.charCodeAt(i), target);
}
if (isValid) {
return displayName;
}
}
@ -1709,7 +1714,6 @@ module ts {
}
var declarations = symbol.getDeclarations();
var firstDeclaration = [0];
return {
name: displayName,
kind: getSymbolKind(symbol),
@ -1721,7 +1725,7 @@ module ts {
function getCompletionEntriesFromSymbols(symbols: Symbol[], session: CompletionSession): void {
forEach(symbols, (symbol) => {
var entry = createCompletionEntry(symbol);
if (entry) {
if (entry && !lookUp(session.symbols, entry.name)) {
session.entries.push(entry);
session.symbols[entry.name] = symbol;
}
@ -1851,6 +1855,49 @@ module ts {
return false;
}
function isPunctuation(kind: SyntaxKind) {
return (SyntaxKind.FirstPunctuation <= kind && kind <= SyntaxKind.LastPunctuation);
}
function isVisibleWithinClassDeclaration(symbol: Symbol, containingClass: Declaration): boolean {
var declaration = symbol.declarations && symbol.declarations[0];
if (declaration && (declaration.flags & NodeFlags.Private)) {
var declarationClass = getAncestor(declaration, SyntaxKind.ClassDeclaration);
return containingClass === declarationClass;
}
return true;
}
function filterContextualMembersList(contextualMemberSymbols: Symbol[], existingMembers: Declaration[]): Symbol[] {
if (!existingMembers || existingMembers.length === 0) {
return contextualMemberSymbols;
}
var existingMemberNames: Map<boolean> = {};
forEach(existingMembers, m => {
if (m.kind !== SyntaxKind.PropertyAssignment) {
// Ignore omitted expressions for missing members in the object literal
return;
}
if (m.getStart() <= position && position <= m.getEnd()) {
// If this is the current item we are editing right now, do not filter it out
return;
}
existingMemberNames[m.name.text] = true;
});
var filteredMembers: Symbol[] = [];
forEach(contextualMemberSymbols, s => {
if (!existingMemberNames[s.name]) {
filteredMembers.push(s);
}
});
return filteredMembers;
}
synchronizeHostData();
filename = TypeScript.switchToForwardSlashes(filename);
@ -1905,6 +1952,9 @@ module ts {
// TODO: this is a hack for now, we need a proper walking mechanism to verify that we have the correct node
var mappedNode = getNodeAtPosition(sourceFile, TypeScript.end(node) - 1);
if (isPunctuation(mappedNode.kind)) {
mappedNode = mappedNode.parent;
}
Debug.assert(mappedNode, "Could not map a Fidelity node to an AST node");
@ -1920,13 +1970,33 @@ module ts {
// Right of dot member completion list
if (isRightOfDot) {
var type: ApparentType = typeInfoResolver.getApparentType(typeInfoResolver.getTypeOfNode(mappedNode));
if (!type) {
return undefined;
var symbols: Symbol[] = [];
var containingClass = getAncestor(mappedNode, SyntaxKind.ClassDeclaration);
isMemberCompletion = true;
if (mappedNode.kind === SyntaxKind.Identifier || mappedNode.kind === SyntaxKind.QualifiedName || mappedNode.kind === SyntaxKind.PropertyAccess) {
var symbol = typeInfoResolver.getSymbolInfo(mappedNode);
if (symbol && symbol.flags & SymbolFlags.HasExports) {
// Extract module or enum members
forEachValue(symbol.exports, symbol => {
if (isVisibleWithinClassDeclaration(symbol, containingClass)) {
symbols.push(symbol);
}
});
}
}
var type = typeInfoResolver.getTypeOfNode(mappedNode);
var apparentType = type && typeInfoResolver.getApparentType(type);
if (apparentType) {
// Filter private properties
forEach(apparentType.getApparentProperties(), symbol => {
if (isVisibleWithinClassDeclaration(symbol, containingClass)) {
symbols.push(symbol);
}
});
}
var symbols = type.getApparentProperties();
isMemberCompletion = true;
getCompletionEntriesFromSymbols(symbols, activeCompletionSession);
}
else {
@ -1934,34 +2004,23 @@ module ts {
// Object literal expression, look up possible property names from contextual type
if (containingObjectLiteral) {
var searchPosition = Math.min(position, TypeScript.end(containingObjectLiteral));
var path = TypeScript.ASTHelpers.getAstAtPosition(sourceUnit, searchPosition);
// Get the object literal node
var objectLiteral = <ObjectLiteral>(mappedNode.kind === SyntaxKind.ObjectLiteral ? mappedNode : getAncestor(mappedNode, SyntaxKind.ObjectLiteral));
while (node && node.kind() !== TypeScript.SyntaxKind.ObjectLiteralExpression) {
node = node.parent;
}
if (!node || node.kind() !== TypeScript.SyntaxKind.ObjectLiteralExpression) {
// AST Path look up did not result in the same node as Fidelity Syntax Tree look up.
// Once we remove AST this will no longer be a problem.
return null;
}
Debug.assert(objectLiteral);
isMemberCompletion = true;
//// Try to get the object members form contextual typing
//var contextualMembers = compiler.getContextualMembersFromAST(node, document);
//if (contextualMembers && contextualMembers.symbols && contextualMembers.symbols.length > 0) {
// // get existing members
// var existingMembers = compiler.getVisibleMemberSymbolsFromAST(node, document);
var contextualType = typeInfoResolver.getContextualType(objectLiteral);
if (!contextualType) {
return undefined;
}
// // Add filtered items to the completion list
// getCompletionEntriesFromSymbols({
// symbols: filterContextualMembersList(contextualMembers.symbols, existingMembers, filename, position),
// enclosingScopeSymbol: contextualMembers.enclosingScopeSymbol
// }, entries);
//}
var contextualTypeMembers = typeInfoResolver.getPropertiesOfType(contextualType);
if (contextualTypeMembers && contextualTypeMembers.length > 0) {
// Add filtered items to the completion list
var filteredMembers = filterContextualMembersList(contextualTypeMembers, objectLiteral.properties);
getCompletionEntriesFromSymbols(filteredMembers, activeCompletionSession);
}
}
// Get scope members
else {
@ -2024,6 +2083,7 @@ module ts {
}
}
/** Get the token whose text contains the position, or the containing node. */
function getNodeAtPosition(sourceFile: SourceFile, position: number) {
var current: Node = sourceFile;
outer: while (true) {
@ -2034,8 +2094,23 @@ module ts {
current = child;
continue outer;
}
if (child.end > position) {
break;
}
return current;
}
}
/** Get a token that contains the position. This is guaranteed to return a token, the position can be in the
* leading trivia or within the token text.
*/
function getTokenAtPosition(sourceFile: SourceFile, position: number) {
var current: Node = sourceFile;
outer: while (true) {
// find the child that has this
for (var i = 0, n = current.getChildCount(); i < n; i++) {
var child = current.getChildAt(i);
if (child.getFullStart() <= position && position < child.getEnd()) {
current = child;
continue outer;
}
}
return current;
@ -2065,7 +2140,7 @@ module ts {
}
function getSymbolKind(symbol: Symbol): string {
var flags = symbol.getFlags();
var flags = typeInfoResolver.getRootSymbol(symbol).getFlags();
if (flags & SymbolFlags.Module) return ScriptElementKind.moduleElement;
if (flags & SymbolFlags.Class) return ScriptElementKind.classElement;
@ -3751,11 +3826,91 @@ module ts {
return [];
}
function getTodoComments(filename: string, descriptors: TodoCommentDescriptor[]): TodoComment[] {
filename = TypeScript.switchToForwardSlashes(filename);
var sourceFile = getCurrentSourceFile(filename);
cancellationToken.throwIfCancellationRequested();
var fileContents = sourceFile.text;
cancellationToken.throwIfCancellationRequested();
var result: TodoComment[] = [];
if (descriptors.length > 0) {
var regExp = getTodoCommentsRegExp();
var matchArray: RegExpExecArray;
while (matchArray = regExp.exec(fileContents)) {
cancellationToken.throwIfCancellationRequested();
// If we got a match, here is what the match array will look like. Say the source text is:
//
// " // hack 1"
//
// The result array with the regexp: will be:
//
// ["// hack 1", "// ", "hack 1", undefined, "hack"]
//
// Here are the relevant capture groups:
// 0) The full match for the entire regexp.
// 1) The preamble to the message portion.
// 2) The message portion.
// 3...N) The descriptor that was matched - by index. 'undefined' for each
// descriptor that didn't match. an actual value if it did match.
//
// i.e. 'undefined' in position 3 above means TODO(jason) didn't match.
// "hack" in position 4 means HACK did match.
var firstDescriptorCaptureIndex = 3;
Debug.assert(matchArray.length === descriptors.length + firstDescriptorCaptureIndex);
var preamble = matchArray[1];
var matchPosition = matchArray.index + preamble.length;
// OK, we have found a match in the file. This is only an acceptable match if
// it is contained within a comment.
var token = getTokenAtPosition(sourceFile, matchPosition);
if (token.getStart() <= matchPosition && matchPosition < token.getEnd()) {
// match was within the token itself. Not in the comment. Keep searching
// descriptor.
continue;
}
// Looks to be within the trivia. See if we can find the comment containing it.
if (!getContainingComment(getTrailingComments(fileContents, token.getFullStart()), matchPosition) &&
!getContainingComment(getLeadingComments(fileContents, token.getFullStart()), matchPosition)) {
continue;
}
var descriptor: TodoCommentDescriptor = undefined;
for (var i = 0, n = descriptors.length; i < n; i++) {
if (matchArray[i + firstDescriptorCaptureIndex]) {
descriptor = descriptors[i];
}
}
Debug.assert(descriptor);
// We don't want to match something like 'TODOBY', so we make sure a non
// letter/digit follows the match.
if (isLetterOrDigit(fileContents.charCodeAt(matchPosition + descriptor.text.length))) {
continue;
}
var message = matchArray[2];
result.push(new TodoComment(descriptor, message, matchPosition));
}
}
return result;
function escapeRegExp(str: string): string {
return str.replace(/[\-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, "\\$&");
}
function getTodoCommentsRegExp(descriptors: TodoCommentDescriptor[]): RegExp {
function getTodoCommentsRegExp(): RegExp {
// NOTE: ?: means 'non-capture group'. It allows us to have groups without having to
// filter them out later in the final result array.
@ -3788,7 +3943,7 @@ module ts {
// Note that the outermost group is *not* a capture group, but the innermost groups
// *are* capture groups. By capturing the inner literals we can determine after
// matching which descriptor we are dealing with.
var literals = "(?:" + descriptors.map(d => "(" + escapeRegExp(d.text) + ")").join("|") + ")";
var literals = "(?:" + map(descriptors, d => "(" + escapeRegExp(d.text) + ")").join("|") + ")";
// After matching a descriptor literal, the following regexp matches the rest of the
// text up to the end of the line (or */).
@ -3809,90 +3964,21 @@ module ts {
//
// 'i' is for case insensitivity (We do this to match C# TODO comment code).
//
// 'm' is so we can find matches in a multiline input.
// 'm' is so we can find matches in a multi-line input.
return new RegExp(regExpString, "gim");
}
function getTodoComments(fileName: string, descriptors: TodoCommentDescriptor[]): TodoComment[] {
fileName = TypeScript.switchToForwardSlashes(fileName);
var sourceFile = getCurrentSourceFile(fileName);
var syntaxTree = sourceFile.getSyntaxTree();
cancellationToken.throwIfCancellationRequested();
var text = syntaxTree.text;
var fileContents = text.substr(0, text.length());
cancellationToken.throwIfCancellationRequested();
var result: TodoComment[] = [];
if (descriptors.length > 0) {
var regExp = getTodoCommentsRegExp(descriptors);
var matchArray: RegExpExecArray;
while (matchArray = regExp.exec(fileContents)) {
cancellationToken.throwIfCancellationRequested();
// If we got a match, here is what the match array will look like. Say the source text is:
//
// " // hack 1"
//
// The result array with the regexp: will be:
//
// ["// hack 1", "// ", "hack 1", undefined, "hack"]
//
// Here are the relevant capture groups:
// 0) The full match for the entire regex.
// 1) The preamble to the message portion.
// 2) The message portion.
// 3...N) The descriptor that was matched - by index. 'undefined' for each
// descriptor that didn't match. an actual value if it did match.
//
// i.e. 'undefined' in position 3 above means TODO(jason) didn't match.
// "hack" in position 4 means HACK did match.
var firstDescriptorCaptureIndex = 3;
Debug.assert(matchArray.length === descriptors.length + firstDescriptorCaptureIndex);
var preamble = matchArray[1];
var matchPosition = matchArray.index + preamble.length;
// Ok, we have found a match in the file. This is only an acceptable match if
// it is contained within a comment.
var token = TypeScript.findToken(syntaxTree.sourceUnit(), matchPosition);
if (matchPosition >= TypeScript.start(token) && matchPosition < TypeScript.end(token)) {
// match was within the token itself. Not in the comment. Keep searching
// descriptor.
continue;
function getContainingComment(comments: Comment[], position: number): Comment {
if (comments) {
for (var i = 0, n = comments.length; i < n; i++) {
var comment = comments[i];
if (comment.pos <= position && position < comment.end) {
return comment;
}
// Looks to be within the trivia. See if we can find the comment containing it.
var triviaList = matchPosition < TypeScript.start(token) ? token.leadingTrivia(syntaxTree.text) : token.trailingTrivia(syntaxTree.text);
var trivia = findContainingComment(triviaList, matchPosition);
if (trivia === null) {
continue;
}
var descriptor: TodoCommentDescriptor = undefined;
for (var i = 0, n = descriptors.length; i < n; i++) {
if (matchArray[i + firstDescriptorCaptureIndex]) {
descriptor = descriptors[i];
}
}
Debug.assert(descriptor);
// We don't want to match something like 'TODOBY', so we make sure a non
// letter/digit follows the match.
if (isLetterOrDigit(fileContents.charCodeAt(matchPosition + descriptor.text.length))) {
continue;
}
var message = matchArray[2];
result.push(new TodoComment(descriptor, message, matchPosition));
}
}
return result;
return undefined;
}
function isLetterOrDigit(char: number): boolean {
@ -3900,17 +3986,33 @@ module ts {
(char >= TypeScript.CharacterCodes.A && char <= TypeScript.CharacterCodes.Z) ||
(char >= TypeScript.CharacterCodes._0 && char <= TypeScript.CharacterCodes._9);
}
}
function findContainingComment(triviaList: TypeScript.ISyntaxTriviaList, position: number): TypeScript.ISyntaxTrivia {
for (var i = 0, n = triviaList.count(); i < n; i++) {
var trivia = triviaList.syntaxTriviaAt(i);
var fullEnd = trivia.fullStart() + trivia.fullWidth();
if (trivia.isComment() && trivia.fullStart() <= position && position < fullEnd) {
return trivia;
function getRenameInfo(fileName: string, position: number): RenameInfo {
synchronizeHostData();
fileName = TypeScript.switchToForwardSlashes(fileName);
var sourceFile = getSourceFile(fileName);
var node = getNodeAtPosition(sourceFile, position);
// Can only rename an identifier.
if (node && node.kind === SyntaxKind.Identifier) {
var symbol = typeInfoResolver.getSymbolInfo(node);
// Only allow a symbol to be renamed if it actually has at least one declaration.
if (symbol && symbol.getDeclarations() && symbol.getDeclarations().length > 0) {
var kind = getSymbolKind(symbol);
if (kind) {
return RenameInfo.Create(symbol.name, typeInfoResolver.getFullyQualifiedName(symbol), kind,
getNodeModifiers(symbol.getDeclarations()[0]),
new TypeScript.TextSpan(node.getStart(), node.getWidth()));
}
}
}
return null;
return RenameInfo.CreateError(getLocaleSpecificMessage(Diagnostics.You_cannot_rename_this_element.key));
}
return {
@ -3933,7 +4035,7 @@ module ts {
getNameOrDottedNameSpan: getNameOrDottedNameSpan,
getBreakpointStatementAtPosition: getBreakpointStatementAtPosition,
getNavigateToItems: getNavigateToItems,
getRenameInfo: (fileName, position): RenameInfo => RenameInfo.CreateError(getLocaleSpecificMessage(Diagnostics.You_cannot_rename_this_element.key)),
getRenameInfo: getRenameInfo,
getNavigationBarItems: getNavigationBarItems,
getOutliningSpans: getOutliningSpans,
getTodoComments: getTodoComments,
@ -3995,9 +4097,6 @@ module ts {
text = "/*\n" + text;
offset = 3;
break;
case EndOfLineState.EndingWithDotToken:
lastToken = SyntaxKind.DotToken;
break;
}
var result: ClassificationResult = {
@ -4005,7 +4104,7 @@ module ts {
entries: []
};
scanner = createScanner(ScriptTarget.ES5, text, onError, processComment);
scanner = createScanner(ScriptTarget.ES5, /*skipTrivia*/ true, text, onError, processComment);
var token = SyntaxKind.Unknown;
do {
@ -4065,9 +4164,6 @@ module ts {
: EndOfLineState.InSingleQuoteStringLiteral;
}
}
else if (token === SyntaxKind.DotToken) {
result.finalLexState = EndOfLineState.EndingWithDotToken;
}
}
}

6
tests/baselines/reference/enumConflictsWithGlobalIdentifier.errors.txt
View file

@ -1,4 +1,4 @@
tests/cases/compiler/enumConflictsWithGlobalIdentifier.ts(5,5): error TS1005: ',' expected.
tests/cases/compiler/enumConflictsWithGlobalIdentifier.ts(4,28): error TS1003: Identifier expected.
tests/cases/compiler/enumConflictsWithGlobalIdentifier.ts(4,9): error TS2304: Cannot find name 'IgnoreRulesSpecific'.
@ -7,9 +7,9 @@ tests/cases/compiler/enumConflictsWithGlobalIdentifier.ts(4,9): error TS2304: Ca
IgnoreRulesSpecific = 0,
}
var x = IgnoreRulesSpecific.
~
!!! error TS1003: Identifier expected.
~~~~~~~~~~~~~~~~~~~
!!! error TS2304: Cannot find name 'IgnoreRulesSpecific'.
var y = Position.IgnoreRulesSpecific;
~
!!! error TS1005: ',' expected.

6
tests/baselines/reference/enumMemberResolution.errors.txt
View file

@ -1,4 +1,4 @@
tests/cases/compiler/enumMemberResolution.ts(5,5): error TS1005: ',' expected.
tests/cases/compiler/enumMemberResolution.ts(4,28): error TS1003: Identifier expected.
tests/cases/compiler/enumMemberResolution.ts(4,9): error TS2304: Cannot find name 'IgnoreRulesSpecific'.
@ -7,10 +7,10 @@ tests/cases/compiler/enumMemberResolution.ts(4,9): error TS2304: Cannot find nam
IgnoreRulesSpecific = 0
}
var x = IgnoreRulesSpecific. // error
~
!!! error TS1003: Identifier expected.
~~~~~~~~~~~~~~~~~~~
!!! error TS2304: Cannot find name 'IgnoreRulesSpecific'.
var y = 1;
~
!!! error TS1005: ',' expected.
var z = Position2.IgnoreRulesSpecific; // no error

2
tests/cases/fourslash_old/completionEntryForPrimitive.ts → tests/cases/fourslash/completionEntryForPrimitive.ts
View file

@ -6,4 +6,4 @@ diagnostics.setEditValidation(IncrementalEditValidation.None);
goTo.marker();
verify.not.completionListIsEmpty();
edit.insert("nu");
verify.completionListContains("number", undefined, undefined, undefined, "primitive type");
verify.completionListContains("number", undefined, undefined, undefined, "keyword");

0
tests/cases/fourslash_old/completionInTypeOf1.ts → tests/cases/fourslash/completionInTypeOf1.ts
View file

0
tests/cases/fourslash_old/completionListAfterNumericLiteral.ts → tests/cases/fourslash/completionListAfterNumericLiteral.ts
View file

0
tests/cases/fourslash_old/completionListAfterObjectLiteral1.ts → tests/cases/fourslash/completionListAfterObjectLiteral1.ts
View file

0
tests/cases/fourslash_old/completionListAtEOF2.ts → tests/cases/fourslash/completionListAtEOF2.ts
View file

0
tests/cases/fourslash_old/completionListAtNodeBoundry.ts → tests/cases/fourslash/completionListAtNodeBoundry.ts
View file

0
tests/cases/fourslash_old/completionListBeforeKeyword.ts → tests/cases/fourslash/completionListBeforeKeyword.ts
View file

0
tests/cases/fourslash_old/completionListCladule.ts → tests/cases/fourslash/completionListCladule.ts
View file

0
tests/cases/fourslash_old/completionListClassMembers.ts → tests/cases/fourslash/completionListClassMembers.ts
View file

0
tests/cases/fourslash_old/completionListEnumMembers.ts → tests/cases/fourslash/completionListEnumMembers.ts
View file

0
tests/cases/fourslash_old/completionListEnumValues.ts → tests/cases/fourslash/completionListEnumValues.ts
View file

6
tests/cases/fourslash_old/completionListForDerivedType1.ts → tests/cases/fourslash/completionListForDerivedType1.ts
View file

@ -12,10 +12,10 @@
////f2./*2*/ // here bar has return type any, but bar2 is Foo2
goTo.marker('1');
verify.completionListContains('bar', '(): IFoo');
verify.completionListContains('bar', '() => IFoo');
verify.not.completionListContains('bar2');
edit.insert('bar();'); // just to make the file valid before checking next completion location
goTo.marker('2');
verify.completionListContains('bar', '(): IFoo');
verify.completionListContains('bar2', '(): IFoo2');
verify.completionListContains('bar', '() => IFoo');
verify.completionListContains('bar2', '() => IFoo2');

0
tests/cases/fourslash_old/completionListForNonExportedMemberInAmbientModuleWithExportAssignment1.ts → tests/cases/fourslash/completionListForNonExportedMemberInAmbientModuleWithExportAssignment1.ts
View file

0
tests/cases/fourslash_old/completionListFunctionExpression.ts → tests/cases/fourslash/completionListFunctionExpression.ts
View file

0
tests/cases/fourslash_old/completionListGenericConstraints.ts → tests/cases/fourslash/completionListGenericConstraints.ts
View file

0
tests/cases/fourslash_old/completionListInContextuallyTypedArgument.ts → tests/cases/fourslash/completionListInContextuallyTypedArgument.ts
View file

15
tests/cases/fourslash_old/completionListInExtendsClause.ts → tests/cases/fourslash/completionListInExtendsClause.ts
View file

@ -18,8 +18,15 @@
////interface test4 implements Foo./*4*/ {}
test.markers().forEach((marker) => {
goTo.position(marker.position, marker.fileName);
goTo.marker("1");
verify.completionListIsEmpty();
verify.completionListIsEmpty();
});
goTo.marker("2");
verify.completionListIsEmpty();
goTo.marker("3");
verify.completionListIsEmpty();
// This needs comletion list filtering based on location to work
goTo.marker("4");
verify.not.completionListIsEmpty();

0
tests/cases/fourslash_old/completionListInExtendsClauseAtEOF.ts → tests/cases/fourslash/completionListInExtendsClauseAtEOF.ts
View file

4
tests/cases/fourslash_old/completionListInNamedFunctionExpression.ts → tests/cases/fourslash/completionListInNamedFunctionExpression.ts
View file

@ -24,9 +24,9 @@ goTo.marker("insideFunctionExpression");
verify.memberListContains("foo");
goTo.marker("referenceInsideFunctionExpression");
verify.quickInfoIs("(): number");
verify.quickInfoIs("() => number");
goTo.marker("referenceInGlobalScope");
verify.quickInfoIs("(a: number): string");
verify.quickInfoIs("(a: number) => string");

0
tests/cases/fourslash_old/completionListInObjectLiteral3.ts → tests/cases/fourslash/completionListInObjectLiteral3.ts
View file

0
tests/cases/fourslash_old/completionListInTypedObjectLiterals2.ts → tests/cases/fourslash/completionListInTypedObjectLiterals2.ts
View file

0
tests/cases/fourslash_old/completionListInTypedObjectLiterals3.ts → tests/cases/fourslash/completionListInTypedObjectLiterals3.ts
View file

0
tests/cases/fourslash_old/completionListInTypedObjectLiterals4.ts → tests/cases/fourslash/completionListInTypedObjectLiterals4.ts
View file

0
tests/cases/fourslash_old/completionListInTypedObjectLiteralsWithPartialPropertyNames.ts → tests/cases/fourslash/completionListInTypedObjectLiteralsWithPartialPropertyNames.ts
View file

0
tests/cases/fourslash_old/completionListInTypedObjectLiteralsWithPartialPropertyNames2.ts → tests/cases/fourslash/completionListInTypedObjectLiteralsWithPartialPropertyNames2.ts
View file

0
tests/cases/fourslash_old/completionListInsideTargetTypedFunction.ts → tests/cases/fourslash/completionListInsideTargetTypedFunction.ts
View file

2
tests/cases/fourslash_old/completionListInvalidMemberNames.ts → tests/cases/fourslash/completionListInvalidMemberNames.ts
View file

@ -19,7 +19,7 @@ verify.completionListContains("bar");
verify.completionListContains("break");
verify.completionListContains("any");
verify.completionListContains("$");
verify.completionListContains("\\u0062");
verify.completionListContains("b");
// Nothing else should show up
verify.memberListCount(5);

0
tests/cases/fourslash_old/completionListInvalidMemberNames2.ts → tests/cases/fourslash/completionListInvalidMemberNames2.ts
View file

0
tests/cases/fourslash_old/completionListModuleMembers.ts → tests/cases/fourslash/completionListModuleMembers.ts
View file

2
tests/cases/fourslash_old/completionListObjectMembers.ts → tests/cases/fourslash/completionListObjectMembers.ts
View file

@ -11,4 +11,4 @@
goTo.marker();
verify.memberListContains("bar", 'any');
verify.memberListContains("foo", '(bar: any): any');
verify.memberListContains("foo", '(bar: any) => any');

11
tests/cases/fourslash/completionListOfGnericSymbol.ts Normal file
View file

@ -0,0 +1,11 @@
/// <reference path="fourslash.ts" />
// Ensure kind is set correctelly on completions of a generic symbol
////var a = [1,2,3];
////a./**/
goTo.marker();
verify.memberListContains('length', "number", /*docComments*/ undefined, /*fullSymbolName*/ undefined,/*kind*/ "property");
verify.memberListContains('toString', "() => string", /*docComments*/ undefined, /*fullSymbolName*/ undefined,/*kind*/ "method");

0
tests/cases/fourslash_old/completionListOnFunctionCallWithOptionalArgument.ts → tests/cases/fourslash/completionListOnFunctionCallWithOptionalArgument.ts
View file

0
tests/cases/fourslash_old/completionListOnParam.ts → tests/cases/fourslash/completionListOnParam.ts
View file

0
tests/cases/fourslash_old/completionListOnVarBetweenModules.ts → tests/cases/fourslash/completionListOnVarBetweenModules.ts
View file

0
tests/cases/fourslash_old/completionListPrimitives.ts → tests/cases/fourslash/completionListPrimitives.ts
View file

0
tests/cases/fourslash_old/completionListPrivateMembers.ts → tests/cases/fourslash/completionListPrivateMembers.ts
View file

17
tests/cases/fourslash/completionListPrivateMembers2.ts Normal file
View file

@ -0,0 +1,17 @@
/// <reference path="fourslash.ts"/>
////class Foo {
//// private y;
//// constructor(private x) {}
//// method() { this./*1*/; }
////}
////var f:Foo;
////f./*2*/
goTo.marker("1");
verify.memberListContains("y");
verify.memberListContains("x");
goTo.marker("2");
verify.not.memberListContains("x");
verify.not.memberListContains("y");

0
tests/cases/fourslash_old/completionListSuperMembers.ts → tests/cases/fourslash/completionListSuperMembers.ts
View file

0
tests/cases/fourslash_old/completionListWithUnresolvedModule.ts → tests/cases/fourslash/completionListWithUnresolvedModule.ts
View file

16
tests/cases/fourslash/findAllRefsInsideWithBlock.ts Normal file
View file

@ -0,0 +1,16 @@
/// <reference path='fourslash.ts'/>
////var x = 0;
////
////with ({}) {
//// var y = x; // Reference of x here should not be picked
//// /*2*/y++; // also reference for y should be ignored
////}
////
////x = /*1*/x + 1;
goTo.marker('1');
verify.referencesCountIs(3);
goTo.marker('2');
verify.referencesCountIs(1);

8
tests/cases/fourslash/fourslash.ts
View file

@ -404,6 +404,14 @@ module FourSlashInterface {
public semanticClassificationsAre(...classifications: { classificationType: string; text: string }[]) {
FourSlash.currentTestState.verifySemanticClassifications(classifications);
}
public renameInfoSucceeded(displayName?: string, fullDisplayName?: string, kind?: string, kindModifiers?: string) {
FourSlash.currentTestState.verifyRenameInfoSucceeded(displayName, fullDisplayName, kind, kindModifiers)
}
public renameInfoFailed(message?: string) {
FourSlash.currentTestState.verifyRenameInfoFailed(message)
}
}
export class edit {

8
tests/cases/fourslash/getRenameInfoTests1.ts Normal file
View file

@ -0,0 +1,8 @@
/// <reference path="fourslash.ts"/>
////class [|/**/C|] {
////
////}
goTo.marker("");
verify.renameInfoSucceeded("C");

8
tests/cases/fourslash/getRenameInfoTests2.ts Normal file
View file

@ -0,0 +1,8 @@
/// <reference path="fourslash.ts"/>
/////**/class C {
////
////}
goTo.marker("");
verify.renameInfoFailed();

0
tests/cases/fourslash_old/memberCompletionFromFunctionCall.ts → tests/cases/fourslash/memberCompletionFromFunctionCall.ts
View file

0
tests/cases/fourslash_old/memberCompletionInForEach1.ts → tests/cases/fourslash/memberCompletionInForEach1.ts
View file

7
tests/cases/fourslash_old/memberCompletionOnTypeParameters.ts → tests/cases/fourslash/memberCompletionOnTypeParameters.ts
View file

@ -5,7 +5,7 @@
//// y: string;
////}
////
////function foo<S, T extends IFoo, U extends T, V extends U>() {
////function foo<S, T extends IFoo, U extends Object, V extends IFoo>() {
//// var s:S, t: T, u: U, v: V;
//// s./*S*/; // no constraint, no completion
//// t./*T*/; // IFoo
@ -22,9 +22,8 @@ verify.memberListContains("y", "string");
verify.memberListCount(2);
goTo.marker("U");
verify.memberListContains("x", "number");
verify.memberListContains("y", "string");
verify.memberListCount(2);
verify.memberListContains("toString", "() => string");
verify.memberListCount(7); // constructor, toString, toLocaleString, valueOf, hasOwnProperty, isPrototypeOf, propertyIsEnumerable
goTo.marker("V");
verify.memberListContains("x", "number");

2
tests/cases/fourslash_old/memberCompletionOnTypeParameters2.ts → tests/cases/fourslash/memberCompletionOnTypeParameters2.ts
View file

@ -10,7 +10,7 @@
//// }
////}
////
////class C<U extends T, T extends A> {
////class C<U extends A, T extends A> {
//// x: U;
//// y = this.x./**/ // completion list here
////}

18
tests/cases/fourslash/memberListInReopenedEnum.ts Normal file
View file

@ -0,0 +1,18 @@
/// <reference path='fourslash.ts'/>
////module M {
//// enum E {
//// A, B
//// }
//// enum E {
//// C = 0, D
//// }
//// var x = E./*1*/
////}
goTo.marker('1');
verify.memberListContains('A', 'E', undefined, "E.A");
verify.memberListContains('B', 'E', undefined, "E.B");
verify.memberListContains('C', 'E', undefined, "E.C");
verify.memberListContains('D', 'E', undefined, "E.D");

2
tests/cases/fourslash_old/memberListInWithBlock.ts → tests/cases/fourslash/memberListInWithBlock.ts
View file

@ -15,8 +15,10 @@ goTo.marker('1');
verify.memberListIsEmpty();
goTo.marker('2');
// Only keywords should show in completion, no members or types
verify.not.completionListContains("foo");
verify.not.completionListContains("f");
verify.not.completionListContains("c");
verify.not.completionListContains("d");
verify.not.completionListContains("x");
verify.not.completionListContains("Object");

12
tests/cases/fourslash/memberListInWithBlock2.ts Normal file
View file

@ -0,0 +1,12 @@
/// <reference path='fourslash.ts'/>
////interface IFoo {
//// a: number;
////}
////
////with (x) {
//// var y: IFoo = { /*1*/ };
////}
goTo.marker('1');
verify.memberListIsEmpty();

7
tests/cases/fourslash/memberListInWithBlock3.ts Normal file
View file

@ -0,0 +1,7 @@
/// <reference path='fourslash.ts'/>
////var x = { a: 0 };
////with(x./*1*/
goTo.marker('1');
verify.memberListContains("a");

0
tests/cases/fourslash_old/memberListInsideObjectLiterals.ts → tests/cases/fourslash/memberListInsideObjectLiterals.ts
View file

2
tests/cases/fourslash_old/memberListOfClass.ts → tests/cases/fourslash/memberListOfClass.ts
View file

@ -11,5 +11,5 @@
goTo.marker();
verify.memberListCount(2);
verify.memberListContains('pubMeth', '(): void');
verify.memberListContains('pubMeth', '() => void');
verify.memberListContains('pubProp', 'number');

0
tests/cases/fourslash_old/memberListOfEnumFromExternalModule.ts → tests/cases/fourslash/memberListOfEnumFromExternalModule.ts
View file

0
tests/cases/fourslash_old/memberListOfExportedClass.ts → tests/cases/fourslash/memberListOfExportedClass.ts
View file

0
tests/cases/fourslash_old/memberListOfModule.ts → tests/cases/fourslash/memberListOfModule.ts
View file

8
tests/cases/fourslash_old/memberListOfModuleBeforeKeyword.ts → tests/cases/fourslash/memberListOfModuleBeforeKeyword.ts
View file

@ -16,9 +16,9 @@
// Verify the memberlist of module when the following line has a keyword
goTo.marker('namedType');
verify.completionListContains('C1', 'TypeModule1.C1');
verify.completionListContains('C2', 'TypeModule1.C2');
verify.completionListContains('C1');
verify.completionListContains('C2');
goTo.marker('dotedExpression');
verify.completionListContains('C1', 'TypeModule1.C1');
verify.completionListContains('C2', 'TypeModule1.C2');
verify.completionListContains('C1');
verify.completionListContains('C2');

0
tests/cases/fourslash_old/memberListOnFunctionParameter.ts → tests/cases/fourslash/memberListOnFunctionParameter.ts
View file

4
tests/cases/fourslash_old/memberListOnThisInClassWithPrivates.ts → tests/cases/fourslash/memberListOnThisInClassWithPrivates.ts
View file

@ -8,6 +8,6 @@
////}
goTo.marker();
verify.memberListContains('privMeth', '(): void');
verify.memberListContains('pubMeth', '(): void');
verify.memberListContains('privMeth', '() => void');
verify.memberListContains('pubMeth', '() => void');
verify.memberListContains('pubProp', 'number');

0
tests/cases/fourslash_old/quickInfoInWithBlock.ts → tests/cases/fourslash/quickInfoInWithBlock.ts
View file

2
tests/cases/fourslash/todoComments1.ts
View file

@ -1,3 +1,3 @@
//// // [|TODO|]
debugger;
verify.todoCommentsInCurrentFile(["TODO"]);

2
tests/cases/fourslash/todoComments10.ts
View file

@ -2,5 +2,5 @@
//// [|todo 1|]
//// [|hack 2|]
//// */
debugger;
verify.todoCommentsInCurrentFile(["TODO", "HACK"]);

2
tests/cases/fourslash/todoComments11.ts
View file

@ -2,5 +2,5 @@
//// [|TODO(jason) 1|]
//// [|HACK 2|]
//// */
debugger;
verify.todoCommentsInCurrentFile(["TODO(jason)", "HACK"]);

2
tests/cases/fourslash/todoComments12.ts
View file

@ -2,5 +2,5 @@
//// [|TODO(jason) 1|]
//// [|HACK 2|]
//// */
debugger;
verify.todoCommentsInCurrentFile(["HACK", "TODO(jason)"]);

1
tests/cases/fourslash/todoComments13.ts
View file

@ -1,4 +1,3 @@
//// TODO
debugger;
verify.todoCommentsInCurrentFile(["TODO"]);

2
tests/cases/fourslash/todoComments14.ts
View file

@ -1,3 +1,3 @@
//// BAR // [|TODO|]
debugger;
verify.todoCommentsInCurrentFile(["TODO"]);

2
tests/cases/fourslash/todoComments15.ts
View file

@ -1,3 +1,3 @@
//// "// HACK 1";
debugger;
verify.todoCommentsInCurrentFile(["TODO(jason)", "HACK"]);

2
tests/cases/fourslash/todoComments16.ts
View file

@ -1,3 +1,3 @@
//// //// [|HACK 1|]
debugger;
verify.todoCommentsInCurrentFile(["TODO(jason)", "HACK"]);

2
tests/cases/fourslash/todoComments17.ts
View file

@ -1,3 +1,3 @@
//// /**** [|HACK 1 |]*/ a
debugger;
verify.todoCommentsInCurrentFile(["TODO(jason)", "HACK"]);

2
tests/cases/fourslash/todoComments2.ts
View file

@ -1,3 +1,3 @@
//// // not TODO
debugger;
verify.todoCommentsInCurrentFile(["TODO"]);

2
tests/cases/fourslash/todoComments3.ts
View file

@ -1,3 +1,3 @@
//// // [|TODO with stuff|]
debugger;
verify.todoCommentsInCurrentFile(["TODO"]);

2
tests/cases/fourslash/todoComments4.ts
View file

@ -1,3 +1,3 @@
//// // TODOnomatch
debugger;
verify.todoCommentsInCurrentFile(["TODO"]);

2
tests/cases/fourslash/todoComments5.ts
View file

@ -2,5 +2,5 @@
//// [|TODO 1|]
//// [|TODO 2|]
//// */
debugger;
verify.todoCommentsInCurrentFile(["TODO"]);

2
tests/cases/fourslash/todoComments6.ts
View file

@ -2,5 +2,5 @@
//// * [|TODO 1|]
//// * [|TODO 2|]
//// */
debugger;
verify.todoCommentsInCurrentFile(["TODO"]);

2
tests/cases/fourslash/todoComments7.ts
View file

@ -2,5 +2,5 @@
//// [|TODO 1|]
//// [|HACK 2|]
//// */
debugger;
verify.todoCommentsInCurrentFile(["TODO", "HACK"]);

2
tests/cases/fourslash/todoComments8.ts
View file

@ -2,5 +2,5 @@
//// [|HACK 1|]
//// [|TODO 2|]
//// */
debugger;
verify.todoCommentsInCurrentFile(["TODO", "HACK"]);

2
tests/cases/fourslash/todoComments9.ts
View file

@ -2,5 +2,5 @@
//// [|TODO HACK|]
//// [|HACK TODO|]
//// */
debugger;
verify.todoCommentsInCurrentFile(["TODO", "HACK"]);

0
tests/cases/fourslash/completionListInObjectLiteralThatIsParameterOfFunctionCall.ts → tests/cases/fourslash_old/completionListInObjectLiteralThatIsParameterOfFunctionCall.ts
View file

18
tests/cases/fourslash_old/memberListInReopenedEnum.ts
View file

@ -1,18 +0,0 @@
/// <reference path='fourslash.ts'/>
////module M {
//// enum E {
//// A, B
//// }
//// enum E {
//// C = 0, D
//// }
//// var x = E./*1*/
////}
goTo.marker('1');
verify.memberListContains('A', 'E', undefined, "M.E.A");
verify.memberListContains('B', 'E', undefined, "M.E.B");
verify.memberListContains('C', 'E', undefined, "M.E.C");
verify.memberListContains('D', 'E', undefined, "M.E.D");

4
tests/cases/unittests/services/colorization.ts
View file

@ -170,8 +170,8 @@ describe('Colorization', function () {
it("classifies keyword after a dot on previous line", function () {
test("var",
ts.EndOfLineState.EndingWithDotToken,
identifier("var"),
ts.EndOfLineState.Start,
keyword("var"),
finalEndOfLineState(ts.EndOfLineState.Start));
});
});