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

Merge branch 'master' into tscJsFiles

Browse source
This commit is contained in:
Sheetal Nandi 2015-10-12 12:51:24 -07:00
parent 6882035dc0 c05297cfea
commit f28fbfd7c5
51 changed files with 2218 additions and 64 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

10
src/compiler/binder.ts
View file

@ -185,8 +185,9 @@ namespace ts {
function declareSymbol(symbolTable: SymbolTable, parent: Symbol, node: Declaration, includes: SymbolFlags, excludes: SymbolFlags): Symbol {
Debug.assert(!hasDynamicName(node));
let isDefaultExport = node.flags & NodeFlags.Default;
// The exported symbol for an export default function/class node is always named "default"
let name = node.flags & NodeFlags.Default && parent ? "default" : getDeclarationName(node);
let name = isDefaultExport && parent ? "default" : getDeclarationName(node);
let symbol: Symbol;
if (name !== undefined) {
@ -227,6 +228,13 @@ namespace ts {
let message = symbol.flags & SymbolFlags.BlockScopedVariable
? Diagnostics.Cannot_redeclare_block_scoped_variable_0
: Diagnostics.Duplicate_identifier_0;
forEach(symbol.declarations, declaration => {
if (declaration.flags & NodeFlags.Default) {
message = Diagnostics.A_module_cannot_have_multiple_default_exports;
}
});
forEach(symbol.declarations, declaration => {
file.bindDiagnostics.push(createDiagnosticForNode(declaration.name || declaration, message, getDisplayName(declaration)));
});

103
src/compiler/checker.ts
View file

@ -610,8 +610,11 @@ namespace ts {
// block - scope variable and namespace module. However, only when we
// try to resolve name in /*1*/ which is used in variable position,
// we want to check for block- scoped
if (meaning & SymbolFlags.BlockScopedVariable && result.flags & SymbolFlags.BlockScopedVariable) {
checkResolvedBlockScopedVariable(result, errorLocation);
if (meaning & SymbolFlags.BlockScopedVariable) {
const exportOrLocalSymbol = getExportSymbolOfValueSymbolIfExported(result);
if (exportOrLocalSymbol.flags & SymbolFlags.BlockScopedVariable) {
checkResolvedBlockScopedVariable(exportOrLocalSymbol, errorLocation);
}
}
}
return result;
@ -7313,15 +7316,15 @@ namespace ts {
}
function checkObjectLiteral(node: ObjectLiteralExpression, contextualMapper?: TypeMapper): Type {
let inDestructuringPattern = isAssignmentTarget(node);
// Grammar checking
checkGrammarObjectLiteralExpression(node);
checkGrammarObjectLiteralExpression(node, inDestructuringPattern);
let propertiesTable: SymbolTable = {};
let propertiesArray: Symbol[] = [];
let contextualType = getContextualType(node);
let contextualTypeHasPattern = contextualType && contextualType.pattern &&
(contextualType.pattern.kind === SyntaxKind.ObjectBindingPattern || contextualType.pattern.kind === SyntaxKind.ObjectLiteralExpression);
let inDestructuringPattern = isAssignmentTarget(node);
let typeFlags: TypeFlags = 0;
for (let memberDecl of node.properties) {
@ -7345,7 +7348,10 @@ namespace ts {
if (inDestructuringPattern) {
// If object literal is an assignment pattern and if the assignment pattern specifies a default value
// for the property, make the property optional.
if (memberDecl.kind === SyntaxKind.PropertyAssignment && hasDefaultValue((<PropertyAssignment>memberDecl).initializer)) {
const isOptional =
(memberDecl.kind === SyntaxKind.PropertyAssignment && hasDefaultValue((<PropertyAssignment>memberDecl).initializer)) ||
(memberDecl.kind === SyntaxKind.ShorthandPropertyAssignment && (<ShorthandPropertyAssignment>memberDecl).objectAssignmentInitializer);
if (isOptional) {
prop.flags |= SymbolFlags.Optional;
}
}
@ -8125,6 +8131,7 @@ namespace ts {
/**
* If indexArgumentExpression is a string literal or number literal, returns its text.
* If indexArgumentExpression is a constant value, returns its string value.
* If indexArgumentExpression is a well known symbol, returns the property name corresponding
* to this symbol, as long as it is a proper symbol reference.
* Otherwise, returns undefined.
@ -8133,6 +8140,12 @@ namespace ts {
if (indexArgumentExpression.kind === SyntaxKind.StringLiteral || indexArgumentExpression.kind === SyntaxKind.NumericLiteral) {
return (<LiteralExpression>indexArgumentExpression).text;
}
if (indexArgumentExpression.kind === SyntaxKind.ElementAccessExpression || indexArgumentExpression.kind === SyntaxKind.PropertyAccessExpression) {
let value = getConstantValue(<ElementAccessExpression | PropertyAccessExpression>indexArgumentExpression);
if (value !== undefined) {
return value.toString();
}
}
if (checkThatExpressionIsProperSymbolReference(indexArgumentExpression, indexArgumentType, /*reportError*/ false)) {
let rightHandSideName = (<Identifier>(<PropertyAccessExpression>indexArgumentExpression).name).text;
return getPropertyNameForKnownSymbolName(rightHandSideName);
@ -9744,7 +9757,7 @@ namespace ts {
return !symbol || symbol === unknownSymbol || (symbol.flags & ~SymbolFlags.EnumMember) !== 0;
}
case SyntaxKind.ElementAccessExpression:
// old compiler doesn't check indexed assess
// old compiler doesn't check indexed access
return true;
case SyntaxKind.ParenthesizedExpression:
return isReferenceOrErrorExpression((<ParenthesizedExpression>n).expression);
@ -9902,32 +9915,32 @@ namespace ts {
return (symbol.flags & SymbolFlags.ConstEnum) !== 0;
}
function checkInstanceOfExpression(node: BinaryExpression, leftType: Type, rightType: Type): Type {
function checkInstanceOfExpression(left: Expression, right: Expression, leftType: Type, rightType: Type): Type {
// TypeScript 1.0 spec (April 2014): 4.15.4
// The instanceof operator requires the left operand to be of type Any, an object type, or a type parameter type,
// and the right operand to be of type Any or a subtype of the 'Function' interface type.
// The result is always of the Boolean primitive type.
// NOTE: do not raise error if leftType is unknown as related error was already reported
if (allConstituentTypesHaveKind(leftType, TypeFlags.Primitive)) {
error(node.left, Diagnostics.The_left_hand_side_of_an_instanceof_expression_must_be_of_type_any_an_object_type_or_a_type_parameter);
error(left, Diagnostics.The_left_hand_side_of_an_instanceof_expression_must_be_of_type_any_an_object_type_or_a_type_parameter);
}
// NOTE: do not raise error if right is unknown as related error was already reported
if (!(isTypeAny(rightType) || isTypeSubtypeOf(rightType, globalFunctionType))) {
error(node.right, Diagnostics.The_right_hand_side_of_an_instanceof_expression_must_be_of_type_any_or_of_a_type_assignable_to_the_Function_interface_type);
error(right, Diagnostics.The_right_hand_side_of_an_instanceof_expression_must_be_of_type_any_or_of_a_type_assignable_to_the_Function_interface_type);
}
return booleanType;
}
function checkInExpression(node: BinaryExpression, leftType: Type, rightType: Type): Type {
function checkInExpression(left: Expression, right: Expression, leftType: Type, rightType: Type): Type {
// TypeScript 1.0 spec (April 2014): 4.15.5
// The in operator requires the left operand to be of type Any, the String primitive type, or the Number primitive type,
// and the right operand to be of type Any, an object type, or a type parameter type.
// The result is always of the Boolean primitive type.
if (!isTypeAnyOrAllConstituentTypesHaveKind(leftType, TypeFlags.StringLike | TypeFlags.NumberLike | TypeFlags.ESSymbol)) {
error(node.left, Diagnostics.The_left_hand_side_of_an_in_expression_must_be_of_type_any_string_number_or_symbol);
error(left, Diagnostics.The_left_hand_side_of_an_in_expression_must_be_of_type_any_string_number_or_symbol);
}
if (!isTypeAnyOrAllConstituentTypesHaveKind(rightType, TypeFlags.ObjectType | TypeFlags.TypeParameter)) {
error(node.right, Diagnostics.The_right_hand_side_of_an_in_expression_must_be_of_type_any_an_object_type_or_a_type_parameter);
error(right, Diagnostics.The_right_hand_side_of_an_in_expression_must_be_of_type_any_an_object_type_or_a_type_parameter);
}
return booleanType;
}
@ -9944,7 +9957,12 @@ namespace ts {
isNumericLiteralName(name.text) && getIndexTypeOfType(sourceType, IndexKind.Number) ||
getIndexTypeOfType(sourceType, IndexKind.String);
if (type) {
checkDestructuringAssignment((<PropertyAssignment>p).initializer || name, type);
if (p.kind === SyntaxKind.ShorthandPropertyAssignment) {
checkDestructuringAssignment(<ShorthandPropertyAssignment>p, type);
}
else {
checkDestructuringAssignment((<PropertyAssignment>p).initializer || name, type);
}
}
else {
error(name, Diagnostics.Type_0_has_no_property_1_and_no_string_index_signature, typeToString(sourceType), declarationNameToString(name));
@ -10004,7 +10022,19 @@ namespace ts {
return sourceType;
}
function checkDestructuringAssignment(target: Expression, sourceType: Type, contextualMapper?: TypeMapper): Type {
function checkDestructuringAssignment(exprOrAssignment: Expression | ShorthandPropertyAssignment, sourceType: Type, contextualMapper?: TypeMapper): Type {
let target: Expression;
if (exprOrAssignment.kind === SyntaxKind.ShorthandPropertyAssignment) {
const prop = <ShorthandPropertyAssignment>exprOrAssignment;
if (prop.objectAssignmentInitializer) {
checkBinaryLikeExpression(prop.name, prop.equalsToken, prop.objectAssignmentInitializer, contextualMapper);
}
target = (<ShorthandPropertyAssignment>exprOrAssignment).name;
}
else {
target = <Expression>exprOrAssignment;
}
if (target.kind === SyntaxKind.BinaryExpression && (<BinaryExpression>target).operatorToken.kind === SyntaxKind.EqualsToken) {
checkBinaryExpression(<BinaryExpression>target, contextualMapper);
target = (<BinaryExpression>target).left;
@ -10027,12 +10057,16 @@ namespace ts {
}
function checkBinaryExpression(node: BinaryExpression, contextualMapper?: TypeMapper) {
let operator = node.operatorToken.kind;
if (operator === SyntaxKind.EqualsToken && (node.left.kind === SyntaxKind.ObjectLiteralExpression || node.left.kind === SyntaxKind.ArrayLiteralExpression)) {
return checkDestructuringAssignment(node.left, checkExpression(node.right, contextualMapper), contextualMapper);
return checkBinaryLikeExpression(node.left, node.operatorToken, node.right, contextualMapper, node);
}
function checkBinaryLikeExpression(left: Expression, operatorToken: Node, right: Expression, contextualMapper?: TypeMapper, errorNode?: Node) {
let operator = operatorToken.kind;
if (operator === SyntaxKind.EqualsToken && (left.kind === SyntaxKind.ObjectLiteralExpression || left.kind === SyntaxKind.ArrayLiteralExpression)) {
return checkDestructuringAssignment(left, checkExpression(right, contextualMapper), contextualMapper);
}
let leftType = checkExpression(node.left, contextualMapper);
let rightType = checkExpression(node.right, contextualMapper);
let leftType = checkExpression(left, contextualMapper);
let rightType = checkExpression(right, contextualMapper);
switch (operator) {
case SyntaxKind.AsteriskToken:
case SyntaxKind.AsteriskEqualsToken:
@ -10068,13 +10102,13 @@ namespace ts {
// try and return them a helpful suggestion
if ((leftType.flags & TypeFlags.Boolean) &&
(rightType.flags & TypeFlags.Boolean) &&
(suggestedOperator = getSuggestedBooleanOperator(node.operatorToken.kind)) !== undefined) {
error(node, Diagnostics.The_0_operator_is_not_allowed_for_boolean_types_Consider_using_1_instead, tokenToString(node.operatorToken.kind), tokenToString(suggestedOperator));
(suggestedOperator = getSuggestedBooleanOperator(operatorToken.kind)) !== undefined) {
error(errorNode || operatorToken, Diagnostics.The_0_operator_is_not_allowed_for_boolean_types_Consider_using_1_instead, tokenToString(operatorToken.kind), tokenToString(suggestedOperator));
}
else {
// otherwise just check each operand separately and report errors as normal
let leftOk = checkArithmeticOperandType(node.left, leftType, Diagnostics.The_left_hand_side_of_an_arithmetic_operation_must_be_of_type_any_number_or_an_enum_type);
let rightOk = checkArithmeticOperandType(node.right, rightType, Diagnostics.The_right_hand_side_of_an_arithmetic_operation_must_be_of_type_any_number_or_an_enum_type);
let leftOk = checkArithmeticOperandType(left, leftType, Diagnostics.The_left_hand_side_of_an_arithmetic_operation_must_be_of_type_any_number_or_an_enum_type);
let rightOk = checkArithmeticOperandType(right, rightType, Diagnostics.The_right_hand_side_of_an_arithmetic_operation_must_be_of_type_any_number_or_an_enum_type);
if (leftOk && rightOk) {
checkAssignmentOperator(numberType);
}
@ -10140,9 +10174,9 @@ namespace ts {
}
return booleanType;
case SyntaxKind.InstanceOfKeyword:
return checkInstanceOfExpression(node, leftType, rightType);
return checkInstanceOfExpression(left, right, leftType, rightType);
case SyntaxKind.InKeyword:
return checkInExpression(node, leftType, rightType);
return checkInExpression(left, right, leftType, rightType);
case SyntaxKind.AmpersandAmpersandToken:
return rightType;
case SyntaxKind.BarBarToken:
@ -10157,8 +10191,8 @@ namespace ts {
// Return true if there was no error, false if there was an error.
function checkForDisallowedESSymbolOperand(operator: SyntaxKind): boolean {
let offendingSymbolOperand =
someConstituentTypeHasKind(leftType, TypeFlags.ESSymbol) ? node.left :
someConstituentTypeHasKind(rightType, TypeFlags.ESSymbol) ? node.right :
someConstituentTypeHasKind(leftType, TypeFlags.ESSymbol) ? left :
someConstituentTypeHasKind(rightType, TypeFlags.ESSymbol) ? right :
undefined;
if (offendingSymbolOperand) {
error(offendingSymbolOperand, Diagnostics.The_0_operator_cannot_be_applied_to_type_symbol, tokenToString(operator));
@ -10192,17 +10226,17 @@ namespace ts {
// requires VarExpr to be classified as a reference
// A compound assignment furthermore requires VarExpr to be classified as a reference (section 4.1)
// and the type of the non - compound operation to be assignable to the type of VarExpr.
let ok = checkReferenceExpression(node.left, Diagnostics.Invalid_left_hand_side_of_assignment_expression, Diagnostics.Left_hand_side_of_assignment_expression_cannot_be_a_constant);
let ok = checkReferenceExpression(left, Diagnostics.Invalid_left_hand_side_of_assignment_expression, Diagnostics.Left_hand_side_of_assignment_expression_cannot_be_a_constant);
// Use default messages
if (ok) {
// to avoid cascading errors check assignability only if 'isReference' check succeeded and no errors were reported
checkTypeAssignableTo(valueType, leftType, node.left, /*headMessage*/ undefined);
checkTypeAssignableTo(valueType, leftType, left, /*headMessage*/ undefined);
}
}
}
function reportOperatorError() {
error(node, Diagnostics.Operator_0_cannot_be_applied_to_types_1_and_2, tokenToString(node.operatorToken.kind), typeToString(leftType), typeToString(rightType));
error(errorNode || operatorToken, Diagnostics.Operator_0_cannot_be_applied_to_types_1_and_2, tokenToString(operatorToken.kind), typeToString(leftType), typeToString(rightType));
}
}
@ -13866,6 +13900,7 @@ namespace ts {
break;
case SyntaxKind.ClassExpression:
forEach((<ClassExpression>node).members, checkSourceElement);
forEachChild(node, checkFunctionAndClassExpressionBodies);
break;
case SyntaxKind.MethodDeclaration:
case SyntaxKind.MethodSignature:
@ -15414,7 +15449,7 @@ namespace ts {
}
}
function checkGrammarObjectLiteralExpression(node: ObjectLiteralExpression) {
function checkGrammarObjectLiteralExpression(node: ObjectLiteralExpression, inDestructuring: boolean) {
let seen: Map<SymbolFlags> = {};
let Property = 1;
let GetAccessor = 2;
@ -15430,6 +15465,12 @@ namespace ts {
continue;
}
if (prop.kind === SyntaxKind.ShorthandPropertyAssignment && !inDestructuring && (<ShorthandPropertyAssignment>prop).objectAssignmentInitializer) {
// having objectAssignmentInitializer is only valid in ObjectAssignmentPattern
// outside of destructuring it is a syntax error
return grammarErrorOnNode((<ShorthandPropertyAssignment>prop).equalsToken, Diagnostics.can_only_be_used_in_an_object_literal_property_inside_a_destructuring_assignment);
}
// ECMA-262 11.1.5 Object Initialiser
// If previous is not undefined then throw a SyntaxError exception if any of the following conditions are true
// a.This production is contained in strict code and IsDataDescriptor(previous) is true and

8
src/compiler/diagnosticMessages.json
View file

@ -800,6 +800,10 @@
"category": "Error",
"code": 1311
},
"'=' can only be used in an object literal property inside a destructuring assignment.": {
"category": "Error",
"code": 1312
},
"Duplicate identifier '{0}'.": {
"category": "Error",
"code": 2300
@ -1656,6 +1660,10 @@
"category": "Error",
"code": 2527
},
"A module cannot have multiple default exports.": {
"category": "Error",
"code": 2528
},
"JSX element attributes type '{0}' must be an object type.": {
"category": "Error",
"code": 2600

22
src/compiler/emitter.ts
View file

@ -2309,6 +2309,11 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
write(": ");
emit(node.name);
}
if (languageVersion >= ScriptTarget.ES6 && node.objectAssignmentInitializer) {
write(" = ");
emit(node.objectAssignmentInitializer);
}
}
function tryEmitConstantValue(node: PropertyAccessExpression | ElementAccessExpression): boolean {
@ -3572,7 +3577,8 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
for (let p of properties) {
if (p.kind === SyntaxKind.PropertyAssignment || p.kind === SyntaxKind.ShorthandPropertyAssignment) {
let propName = <Identifier | LiteralExpression>(<PropertyAssignment>p).name;
emitDestructuringAssignment((<PropertyAssignment>p).initializer || propName, createPropertyAccessForDestructuringProperty(value, propName));
let target = p.kind === SyntaxKind.ShorthandPropertyAssignment ? <ShorthandPropertyAssignment>p : (<PropertyAssignment>p).initializer || propName;
emitDestructuringAssignment(target, createPropertyAccessForDestructuringProperty(value, propName));
}
}
}
@ -3597,8 +3603,14 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
}
}
function emitDestructuringAssignment(target: Expression, value: Expression) {
if (target.kind === SyntaxKind.BinaryExpression && (<BinaryExpression>target).operatorToken.kind === SyntaxKind.EqualsToken) {
function emitDestructuringAssignment(target: Expression | ShorthandPropertyAssignment, value: Expression) {
if (target.kind === SyntaxKind.ShorthandPropertyAssignment) {
if ((<ShorthandPropertyAssignment>target).objectAssignmentInitializer) {
value = createDefaultValueCheck(value, (<ShorthandPropertyAssignment>target).objectAssignmentInitializer);
}
target = (<ShorthandPropertyAssignment>target).name;
}
else if (target.kind === SyntaxKind.BinaryExpression && (<BinaryExpression>target).operatorToken.kind === SyntaxKind.EqualsToken) {
value = createDefaultValueCheck(value, (<BinaryExpression>target).right);
target = (<BinaryExpression>target).left;
}
@ -6845,7 +6857,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
if (isLineBreak(c)) {
if (firstNonWhitespace !== -1 && (lastNonWhitespace - firstNonWhitespace + 1 > 0)) {
let part = text.substr(firstNonWhitespace, lastNonWhitespace - firstNonWhitespace + 1);
result = (result ? result + "\" + ' ' + \"" : "") + part;
result = (result ? result + "\" + ' ' + \"" : "") + escapeString(part);
}
firstNonWhitespace = -1;
}
@ -6859,7 +6871,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
if (firstNonWhitespace !== -1) {
let part = text.substr(firstNonWhitespace);
result = (result ? result + "\" + ' ' + \"" : "") + part;
result = (result ? result + "\" + ' ' + \"" : "") + escapeString(part);
}
if (result) {

24
src/compiler/parser.ts
View file

@ -57,11 +57,17 @@ namespace ts {
return visitNode(cbNode, (<TypeParameterDeclaration>node).name) ||
visitNode(cbNode, (<TypeParameterDeclaration>node).constraint) ||
visitNode(cbNode, (<TypeParameterDeclaration>node).expression);
case SyntaxKind.ShorthandPropertyAssignment:
return visitNodes(cbNodes, node.decorators) ||
visitNodes(cbNodes, node.modifiers) ||
visitNode(cbNode, (<ShorthandPropertyAssignment>node).name) ||
visitNode(cbNode, (<ShorthandPropertyAssignment>node).questionToken) ||
visitNode(cbNode, (<ShorthandPropertyAssignment>node).equalsToken) ||
visitNode(cbNode, (<ShorthandPropertyAssignment>node).objectAssignmentInitializer);
case SyntaxKind.Parameter:
case SyntaxKind.PropertyDeclaration:
case SyntaxKind.PropertySignature:
case SyntaxKind.PropertyAssignment:
case SyntaxKind.ShorthandPropertyAssignment:
case SyntaxKind.VariableDeclaration:
case SyntaxKind.BindingElement:
return visitNodes(cbNodes, node.decorators) ||
@ -3762,11 +3768,23 @@ namespace ts {
return parseMethodDeclaration(fullStart, decorators, modifiers, asteriskToken, propertyName, questionToken);
}
// Parse to check if it is short-hand property assignment or normal property assignment
if ((token === SyntaxKind.CommaToken || token === SyntaxKind.CloseBraceToken) && tokenIsIdentifier) {
// check if it is short-hand property assignment or normal property assignment
// NOTE: if token is EqualsToken it is interpreted as CoverInitializedName production
// CoverInitializedName[Yield] :
// IdentifierReference[?Yield] Initializer[In, ?Yield]
// this is necessary because ObjectLiteral productions are also used to cover grammar for ObjectAssignmentPattern
const isShorthandPropertyAssignment =
tokenIsIdentifier && (token === SyntaxKind.CommaToken || token === SyntaxKind.CloseBraceToken || token === SyntaxKind.EqualsToken);
if (isShorthandPropertyAssignment) {
let shorthandDeclaration = <ShorthandPropertyAssignment>createNode(SyntaxKind.ShorthandPropertyAssignment, fullStart);
shorthandDeclaration.name = <Identifier>propertyName;
shorthandDeclaration.questionToken = questionToken;
const equalsToken = parseOptionalToken(SyntaxKind.EqualsToken);
if (equalsToken) {
shorthandDeclaration.equalsToken = equalsToken;
shorthandDeclaration.objectAssignmentInitializer = allowInAnd(parseAssignmentExpressionOrHigher);
}
return finishNode(shorthandDeclaration);
}
else {

4
src/compiler/types.ts
View file

@ -562,6 +562,10 @@ namespace ts {
export interface ShorthandPropertyAssignment extends ObjectLiteralElement {
name: Identifier;
questionToken?: Node;
// used when ObjectLiteralExpression is used in ObjectAssignmentPattern
// it is grammar error to appear in actual object initializer
equalsToken?: Node;
objectAssignmentInitializer?: Expression;
}
// SyntaxKind.VariableDeclaration

19
src/harness/fourslash.ts
View file

@ -100,6 +100,8 @@ namespace FourSlash {
end: number;
}
export import IndentStyle = ts.IndentStyle;
let entityMap: ts.Map<string> = {
"&": "&amp;",
"\"": "&quot;",
@ -309,6 +311,7 @@ namespace FourSlash {
TabSize: 4,
NewLineCharacter: Harness.IO.newLine(),
ConvertTabsToSpaces: true,
IndentStyle: ts.IndentStyle.Smart,
InsertSpaceAfterCommaDelimiter: true,
InsertSpaceAfterSemicolonInForStatements: true,
InsertSpaceBeforeAndAfterBinaryOperators: true,
@ -1695,24 +1698,28 @@ namespace FourSlash {
}
}
private getIndentation(fileName: string, position: number): number {
return this.languageService.getIndentationAtPosition(fileName, position, this.formatCodeOptions);
private getIndentation(fileName: string, position: number, indentStyle: ts.IndentStyle): number {
let formatOptions = ts.clone(this.formatCodeOptions);
formatOptions.IndentStyle = indentStyle;
return this.languageService.getIndentationAtPosition(fileName, position, formatOptions);
}
public verifyIndentationAtCurrentPosition(numberOfSpaces: number) {
public verifyIndentationAtCurrentPosition(numberOfSpaces: number, indentStyle: ts.IndentStyle = ts.IndentStyle.Smart) {
this.taoInvalidReason = "verifyIndentationAtCurrentPosition NYI";
let actual = this.getIndentation(this.activeFile.fileName, this.currentCaretPosition);
let actual = this.getIndentation(this.activeFile.fileName, this.currentCaretPosition, indentStyle);
let lineCol = this.getLineColStringAtPosition(this.currentCaretPosition);
if (actual !== numberOfSpaces) {
this.raiseError(`verifyIndentationAtCurrentPosition failed at ${lineCol} - expected: ${numberOfSpaces}, actual: ${actual}`);
}
}
public verifyIndentationAtPosition(fileName: string, position: number, numberOfSpaces: number) {
public verifyIndentationAtPosition(fileName: string, position: number, numberOfSpaces: number, indentStyle: ts.IndentStyle = ts.IndentStyle.Smart) {
this.taoInvalidReason = "verifyIndentationAtPosition NYI";
let actual = this.getIndentation(fileName, position);
let actual = this.getIndentation(fileName, position, indentStyle);
let lineCol = this.getLineColStringAtPosition(position);
if (actual !== numberOfSpaces) {
this.raiseError(`verifyIndentationAtPosition failed at ${lineCol} - expected: ${numberOfSpaces}, actual: ${actual}`);

5
src/lib/dom.generated.d.ts vendored
View file

@ -7893,6 +7893,10 @@ declare var Node: {
}
interface NodeFilter {
acceptNode(n: Node): number;
}
declare var NodeFilter: {
FILTER_ACCEPT: number;
FILTER_REJECT: number;
FILTER_SKIP: number;
@ -7910,7 +7914,6 @@ interface NodeFilter {
SHOW_PROCESSING_INSTRUCTION: number;
SHOW_TEXT: number;
}
declare var NodeFilter: NodeFilter;
interface NodeIterator {
expandEntityReferences: boolean;

2
src/server/editorServices.ts
View file

@ -1177,6 +1177,7 @@ namespace ts.server {
TabSize: 4,
NewLineCharacter: ts.sys ? ts.sys.newLine : '\n',
ConvertTabsToSpaces: true,
IndentStyle: ts.IndentStyle.Smart,
InsertSpaceAfterCommaDelimiter: true,
InsertSpaceAfterSemicolonInForStatements: true,
InsertSpaceBeforeAndAfterBinaryOperators: true,
@ -1187,7 +1188,6 @@ namespace ts.server {
PlaceOpenBraceOnNewLineForFunctions: false,
PlaceOpenBraceOnNewLineForControlBlocks: false,
}
}
export interface LineCollection {

1
src/server/session.ts
View file

@ -606,6 +606,7 @@ namespace ts.server {
TabSize: formatOptions.TabSize,
NewLineCharacter: "\n",
ConvertTabsToSpaces: formatOptions.ConvertTabsToSpaces,
IndentStyle: ts.IndentStyle.Smart,
};
var indentPosition =
compilerService.languageService.getIndentationAtPosition(file, position, editorOptions);

8
src/services/formatting/rules.ts
View file

@ -214,6 +214,7 @@ namespace ts.formatting {
public SpaceBetweenYieldOrYieldStarAndOperand: Rule;
// Async functions
public SpaceBetweenAsyncAndOpenParen: Rule;
public SpaceBetweenAsyncAndFunctionKeyword: Rule;
// Template strings
@ -369,6 +370,7 @@ namespace ts.formatting {
this.SpaceBetweenYieldOrYieldStarAndOperand = new Rule(RuleDescriptor.create4(Shared.TokenRange.FromTokens([SyntaxKind.YieldKeyword, SyntaxKind.AsteriskToken]), Shared.TokenRange.Any), RuleOperation.create2(new RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsYieldOrYieldStarWithOperand), RuleAction.Space));
// Async-await
this.SpaceBetweenAsyncAndOpenParen = new Rule(RuleDescriptor.create1(SyntaxKind.AsyncKeyword, SyntaxKind.OpenParenToken), RuleOperation.create2(new RuleOperationContext(Rules.IsArrowFunctionContext, Rules.IsSameLineTokenContext), RuleAction.Space));
this.SpaceBetweenAsyncAndFunctionKeyword = new Rule(RuleDescriptor.create1(SyntaxKind.AsyncKeyword, SyntaxKind.FunctionKeyword), RuleOperation.create2(new RuleOperationContext(Rules.IsSameLineTokenContext), RuleAction.Space));
// template string
@ -402,7 +404,7 @@ namespace ts.formatting {
this.NoSpaceBeforeOpenParenInFuncCall,
this.SpaceBeforeBinaryKeywordOperator, this.SpaceAfterBinaryKeywordOperator,
this.SpaceAfterVoidOperator,
this.SpaceBetweenAsyncAndFunctionKeyword,
this.SpaceBetweenAsyncAndOpenParen, this.SpaceBetweenAsyncAndFunctionKeyword,
this.SpaceBetweenTagAndTemplateString, this.NoSpaceAfterTemplateHeadAndMiddle, this.NoSpaceBeforeTemplateMiddleAndTail,
// TypeScript-specific rules
@ -703,6 +705,10 @@ namespace ts.formatting {
return context.currentTokenSpan.kind !== SyntaxKind.CommaToken;
}
static IsArrowFunctionContext(context: FormattingContext): boolean {
return context.contextNode.kind === SyntaxKind.ArrowFunction;
}
static IsSameLineTokenContext(context: FormattingContext): boolean {
return context.TokensAreOnSameLine();
}

32
src/services/formatting/smartIndenter.ts
View file

@ -13,6 +13,12 @@ namespace ts.formatting {
return 0; // past EOF
}
// no indentation when the indent style is set to none,
// so we can return fast
if (options.IndentStyle === IndentStyle.None) {
return 0;
}
let precedingToken = findPrecedingToken(position, sourceFile);
if (!precedingToken) {
return 0;
@ -26,6 +32,26 @@ namespace ts.formatting {
let lineAtPosition = sourceFile.getLineAndCharacterOfPosition(position).line;
// indentation is first non-whitespace character in a previous line
// for block indentation, we should look for a line which contains something that's not
// whitespace.
if (options.IndentStyle === IndentStyle.Block) {
// move backwards until we find a line with a non-whitespace character,
// then find the first non-whitespace character for that line.
let current = position;
while (current > 0){
let char = sourceFile.text.charCodeAt(current);
if (!isWhiteSpace(char) && !isLineBreak(char)) {
break;
}
current--;
}
let lineStart = ts.getLineStartPositionForPosition(current, sourceFile);
return SmartIndenter.findFirstNonWhitespaceColumn(lineStart, current, sourceFile, options);
}
if (precedingToken.kind === SyntaxKind.CommaToken && precedingToken.parent.kind !== SyntaxKind.BinaryExpression) {
// previous token is comma that separates items in list - find the previous item and try to derive indentation from it
let actualIndentation = getActualIndentationForListItemBeforeComma(precedingToken, sourceFile, options);
@ -218,7 +244,7 @@ namespace ts.formatting {
function getStartLineAndCharacterForNode(n: Node, sourceFile: SourceFile): LineAndCharacter {
return sourceFile.getLineAndCharacterOfPosition(n.getStart(sourceFile));
}
export function childStartsOnTheSameLineWithElseInIfStatement(parent: Node, child: TextRangeWithKind, childStartLine: number, sourceFile: SourceFile): boolean {
if (parent.kind === SyntaxKind.IfStatement && (<IfStatement>parent).elseStatement === child) {
let elseKeyword = findChildOfKind(parent, SyntaxKind.ElseKeyword, sourceFile);
@ -319,7 +345,7 @@ namespace ts.formatting {
}
return Value.Unknown;
function getStartingExpression(node: PropertyAccessExpression | CallExpression | ElementAccessExpression) {
while (true) {
switch (node.kind) {
@ -465,4 +491,4 @@ namespace ts.formatting {
}
}
}
}
}

7
src/services/services.ts
View file

@ -1189,6 +1189,13 @@ namespace ts {
TabSize: number;
NewLineCharacter: string;
ConvertTabsToSpaces: boolean;
IndentStyle: IndentStyle;
}
export enum IndentStyle {
None = 0,
Block = 1,
Smart = 2,
}
export interface FormatCodeOptions extends EditorOptions {

47
tests/baselines/reference/constIndexedAccess.js Normal file
View file

@ -0,0 +1,47 @@
//// [constIndexedAccess.ts]
const enum numbers {
zero,
one
}
interface indexAccess {
0: string;
1: number;
}
let test: indexAccess;
let s = test[0];
let n = test[1];
let s1 = test[numbers.zero];
let n1 = test[numbers.one];
let s2 = test[numbers["zero"]];
let n2 = test[numbers["one"]];
enum numbersNotConst {
zero,
one
}
let s3 = test[numbersNotConst.zero];
let n3 = test[numbersNotConst.one];
//// [constIndexedAccess.js]
var test;
var s = test[0];
var n = test[1];
var s1 = test[0 /* zero */];
var n1 = test[1 /* one */];
var s2 = test[0 /* "zero" */];
var n2 = test[1 /* "one" */];
var numbersNotConst;
(function (numbersNotConst) {
numbersNotConst[numbersNotConst["zero"] = 0] = "zero";
numbersNotConst[numbersNotConst["one"] = 1] = "one";
})(numbersNotConst || (numbersNotConst = {}));
var s3 = test[numbersNotConst.zero];
var n3 = test[numbersNotConst.one];

83
tests/baselines/reference/constIndexedAccess.symbols Normal file
View file

@ -0,0 +1,83 @@
=== tests/cases/compiler/constIndexedAccess.ts ===
const enum numbers {
>numbers : Symbol(numbers, Decl(constIndexedAccess.ts, 0, 0))
zero,
>zero : Symbol(numbers.zero, Decl(constIndexedAccess.ts, 1, 20))
one
>one : Symbol(numbers.one, Decl(constIndexedAccess.ts, 2, 9))
}
interface indexAccess {
>indexAccess : Symbol(indexAccess, Decl(constIndexedAccess.ts, 4, 1))
0: string;
1: number;
}
let test: indexAccess;
>test : Symbol(test, Decl(constIndexedAccess.ts, 11, 3))
>indexAccess : Symbol(indexAccess, Decl(constIndexedAccess.ts, 4, 1))
let s = test[0];
>s : Symbol(s, Decl(constIndexedAccess.ts, 13, 3))
>test : Symbol(test, Decl(constIndexedAccess.ts, 11, 3))
>0 : Symbol(indexAccess.0, Decl(constIndexedAccess.ts, 6, 23))
let n = test[1];
>n : Symbol(n, Decl(constIndexedAccess.ts, 14, 3))
>test : Symbol(test, Decl(constIndexedAccess.ts, 11, 3))
>1 : Symbol(indexAccess.1, Decl(constIndexedAccess.ts, 7, 14))
let s1 = test[numbers.zero];
>s1 : Symbol(s1, Decl(constIndexedAccess.ts, 16, 3))
>test : Symbol(test, Decl(constIndexedAccess.ts, 11, 3))
>numbers.zero : Symbol(numbers.zero, Decl(constIndexedAccess.ts, 1, 20))
>numbers : Symbol(numbers, Decl(constIndexedAccess.ts, 0, 0))
>zero : Symbol(numbers.zero, Decl(constIndexedAccess.ts, 1, 20))
let n1 = test[numbers.one];
>n1 : Symbol(n1, Decl(constIndexedAccess.ts, 17, 3))
>test : Symbol(test, Decl(constIndexedAccess.ts, 11, 3))
>numbers.one : Symbol(numbers.one, Decl(constIndexedAccess.ts, 2, 9))
>numbers : Symbol(numbers, Decl(constIndexedAccess.ts, 0, 0))
>one : Symbol(numbers.one, Decl(constIndexedAccess.ts, 2, 9))
let s2 = test[numbers["zero"]];
>s2 : Symbol(s2, Decl(constIndexedAccess.ts, 19, 3))
>test : Symbol(test, Decl(constIndexedAccess.ts, 11, 3))
>numbers : Symbol(numbers, Decl(constIndexedAccess.ts, 0, 0))
>"zero" : Symbol(numbers.zero, Decl(constIndexedAccess.ts, 1, 20))
let n2 = test[numbers["one"]];
>n2 : Symbol(n2, Decl(constIndexedAccess.ts, 20, 3))
>test : Symbol(test, Decl(constIndexedAccess.ts, 11, 3))
>numbers : Symbol(numbers, Decl(constIndexedAccess.ts, 0, 0))
>"one" : Symbol(numbers.one, Decl(constIndexedAccess.ts, 2, 9))
enum numbersNotConst {
>numbersNotConst : Symbol(numbersNotConst, Decl(constIndexedAccess.ts, 20, 30))
zero,
>zero : Symbol(numbersNotConst.zero, Decl(constIndexedAccess.ts, 22, 22))
one
>one : Symbol(numbersNotConst.one, Decl(constIndexedAccess.ts, 23, 9))
}
let s3 = test[numbersNotConst.zero];
>s3 : Symbol(s3, Decl(constIndexedAccess.ts, 27, 3))
>test : Symbol(test, Decl(constIndexedAccess.ts, 11, 3))
>numbersNotConst.zero : Symbol(numbersNotConst.zero, Decl(constIndexedAccess.ts, 22, 22))
>numbersNotConst : Symbol(numbersNotConst, Decl(constIndexedAccess.ts, 20, 30))
>zero : Symbol(numbersNotConst.zero, Decl(constIndexedAccess.ts, 22, 22))
let n3 = test[numbersNotConst.one];
>n3 : Symbol(n3, Decl(constIndexedAccess.ts, 28, 3))
>test : Symbol(test, Decl(constIndexedAccess.ts, 11, 3))
>numbersNotConst.one : Symbol(numbersNotConst.one, Decl(constIndexedAccess.ts, 23, 9))
>numbersNotConst : Symbol(numbersNotConst, Decl(constIndexedAccess.ts, 20, 30))
>one : Symbol(numbersNotConst.one, Decl(constIndexedAccess.ts, 23, 9))

93
tests/baselines/reference/constIndexedAccess.types Normal file
View file

@ -0,0 +1,93 @@
=== tests/cases/compiler/constIndexedAccess.ts ===
const enum numbers {
>numbers : numbers
zero,
>zero : numbers
one
>one : numbers
}
interface indexAccess {
>indexAccess : indexAccess
0: string;
1: number;
}
let test: indexAccess;
>test : indexAccess
>indexAccess : indexAccess
let s = test[0];
>s : string
>test[0] : string
>test : indexAccess
>0 : number
let n = test[1];
>n : number
>test[1] : number
>test : indexAccess
>1 : number
let s1 = test[numbers.zero];
>s1 : string
>test[numbers.zero] : string
>test : indexAccess
>numbers.zero : numbers
>numbers : typeof numbers
>zero : numbers
let n1 = test[numbers.one];
>n1 : number
>test[numbers.one] : number
>test : indexAccess
>numbers.one : numbers
>numbers : typeof numbers
>one : numbers
let s2 = test[numbers["zero"]];
>s2 : string
>test[numbers["zero"]] : string
>test : indexAccess
>numbers["zero"] : numbers
>numbers : typeof numbers
>"zero" : string
let n2 = test[numbers["one"]];
>n2 : number
>test[numbers["one"]] : number
>test : indexAccess
>numbers["one"] : numbers
>numbers : typeof numbers
>"one" : string
enum numbersNotConst {
>numbersNotConst : numbersNotConst
zero,
>zero : numbersNotConst
one
>one : numbersNotConst
}
let s3 = test[numbersNotConst.zero];
>s3 : any
>test[numbersNotConst.zero] : any
>test : indexAccess
>numbersNotConst.zero : numbersNotConst
>numbersNotConst : typeof numbersNotConst
>zero : numbersNotConst
let n3 = test[numbersNotConst.one];
>n3 : any
>test[numbersNotConst.one] : any
>test : indexAccess
>numbersNotConst.one : numbersNotConst
>numbersNotConst : typeof numbersNotConst
>one : numbersNotConst

16
tests/baselines/reference/defaultExportWithOverloads01.js Normal file
View file

@ -0,0 +1,16 @@
//// [defaultExportWithOverloads01.ts]
export default function f();
export default function f(x: string);
export default function f(...args: any[]) {
}
//// [defaultExportWithOverloads01.js]
function f() {
var args = [];
for (var _i = 0; _i < arguments.length; _i++) {
args[_i - 0] = arguments[_i];
}
}
Object.defineProperty(exports, "__esModule", { value: true });
exports.default = f;

13
tests/baselines/reference/defaultExportWithOverloads01.symbols Normal file
View file

@ -0,0 +1,13 @@
=== tests/cases/conformance/es6/modules/defaultExportWithOverloads01.ts ===
export default function f();
>f : Symbol(f, Decl(defaultExportWithOverloads01.ts, 0, 0), Decl(defaultExportWithOverloads01.ts, 1, 28), Decl(defaultExportWithOverloads01.ts, 2, 37))
export default function f(x: string);
>f : Symbol(f, Decl(defaultExportWithOverloads01.ts, 0, 0), Decl(defaultExportWithOverloads01.ts, 1, 28), Decl(defaultExportWithOverloads01.ts, 2, 37))
>x : Symbol(x, Decl(defaultExportWithOverloads01.ts, 2, 26))
export default function f(...args: any[]) {
>f : Symbol(f, Decl(defaultExportWithOverloads01.ts, 0, 0), Decl(defaultExportWithOverloads01.ts, 1, 28), Decl(defaultExportWithOverloads01.ts, 2, 37))
>args : Symbol(args, Decl(defaultExportWithOverloads01.ts, 3, 26))
}

13
tests/baselines/reference/defaultExportWithOverloads01.types Normal file
View file

@ -0,0 +1,13 @@
=== tests/cases/conformance/es6/modules/defaultExportWithOverloads01.ts ===
export default function f();
>f : { (): any; (x: string): any; }
export default function f(x: string);
>f : { (): any; (x: string): any; }
>x : string
export default function f(...args: any[]) {
>f : { (): any; (x: string): any; }
>args : any[]
}

44
tests/baselines/reference/exportedBlockScopedDeclarations.errors.txt Normal file
View file

@ -0,0 +1,44 @@
tests/cases/compiler/exportedBlockScopedDeclarations.ts(1,13): error TS2448: Block-scoped variable 'foo' used before its declaration.
tests/cases/compiler/exportedBlockScopedDeclarations.ts(2,20): error TS2448: Block-scoped variable 'bar' used before its declaration.
tests/cases/compiler/exportedBlockScopedDeclarations.ts(4,15): error TS2448: Block-scoped variable 'bar' used before its declaration.
tests/cases/compiler/exportedBlockScopedDeclarations.ts(7,22): error TS2448: Block-scoped variable 'bar' used before its declaration.
tests/cases/compiler/exportedBlockScopedDeclarations.ts(10,12): error TS2448: Block-scoped variable 'foo1' used before its declaration.
tests/cases/compiler/exportedBlockScopedDeclarations.ts(11,19): error TS2448: Block-scoped variable 'bar1' used before its declaration.
tests/cases/compiler/exportedBlockScopedDeclarations.ts(13,14): error TS2448: Block-scoped variable 'bar1' used before its declaration.
tests/cases/compiler/exportedBlockScopedDeclarations.ts(16,21): error TS2448: Block-scoped variable 'bar1' used before its declaration.
==== tests/cases/compiler/exportedBlockScopedDeclarations.ts (8 errors) ====
const foo = foo; // compile error
~~~
!!! error TS2448: Block-scoped variable 'foo' used before its declaration.
export const bar = bar; // should be compile error
~~~
!!! error TS2448: Block-scoped variable 'bar' used before its declaration.
function f() {
const bar = bar; // compile error
~~~
!!! error TS2448: Block-scoped variable 'bar' used before its declaration.
}
namespace NS {
export const bar = bar; // should be compile error
~~~
!!! error TS2448: Block-scoped variable 'bar' used before its declaration.
}
let foo1 = foo1; // compile error
~~~~
!!! error TS2448: Block-scoped variable 'foo1' used before its declaration.
export let bar1 = bar1; // should be compile error
~~~~
!!! error TS2448: Block-scoped variable 'bar1' used before its declaration.
function f1() {
let bar1 = bar1; // compile error
~~~~
!!! error TS2448: Block-scoped variable 'bar1' used before its declaration.
}
namespace NS1 {
export let bar1 = bar1; // should be compile error
~~~~
!!! error TS2448: Block-scoped variable 'bar1' used before its declaration.
}

40
tests/baselines/reference/exportedBlockScopedDeclarations.js Normal file
View file

@ -0,0 +1,40 @@
//// [exportedBlockScopedDeclarations.ts]
const foo = foo; // compile error
export const bar = bar; // should be compile error
function f() {
const bar = bar; // compile error
}
namespace NS {
export const bar = bar; // should be compile error
}
let foo1 = foo1; // compile error
export let bar1 = bar1; // should be compile error
function f1() {
let bar1 = bar1; // compile error
}
namespace NS1 {
export let bar1 = bar1; // should be compile error
}
//// [exportedBlockScopedDeclarations.js]
define(["require", "exports"], function (require, exports) {
var foo = foo; // compile error
exports.bar = exports.bar; // should be compile error
function f() {
var bar = bar; // compile error
}
var NS;
(function (NS) {
NS.bar = NS.bar; // should be compile error
})(NS || (NS = {}));
var foo1 = foo1; // compile error
exports.bar1 = exports.bar1; // should be compile error
function f1() {
var bar1 = bar1; // compile error
}
var NS1;
(function (NS1) {
NS1.bar1 = NS1.bar1; // should be compile error
})(NS1 || (NS1 = {}));
});

6
tests/baselines/reference/for-of48.errors.txt
View file

@ -1,4 +1,4 @@
tests/cases/conformance/es6/for-ofStatements/for-of48.ts(4,12): error TS1005: ':' expected.
tests/cases/conformance/es6/for-ofStatements/for-of48.ts(4,10): error TS2322: Type 'boolean' is not assignable to type 'number'.
==== tests/cases/conformance/es6/for-ofStatements/for-of48.ts (1 errors) ====
@ -6,8 +6,8 @@ tests/cases/conformance/es6/for-ofStatements/for-of48.ts(4,12): error TS1005: ':
var array = [{ x: "", y: true }]
enum E { x }
for ({x, y = E.x} of array) {
~
!!! error TS1005: ':' expected.
~
!!! error TS2322: Type 'boolean' is not assignable to type 'number'.
x;
y;
}

2
tests/baselines/reference/for-of48.js
View file

@ -14,7 +14,7 @@ var E;
(function (E) {
E[E["x"] = 0] = "x";
})(E || (E = {}));
for ({ x, y: = E.x } of array) {
for ({ x, y = E.x } of array) {
x;
y;
}

25
tests/baselines/reference/functionsInClassExpressions.js Normal file
View file

@ -0,0 +1,25 @@
//// [functionsInClassExpressions.ts]
let Foo = class {
constructor() {
this.bar++;
}
bar = 0;
inc = () => {
this.bar++;
}
m() { return this.bar; }
}
//// [functionsInClassExpressions.js]
var Foo = (function () {
function class_1() {
var _this = this;
this.bar = 0;
this.inc = function () {
_this.bar++;
};
this.bar++;
}
class_1.prototype.m = function () { return this.bar; };
return class_1;
})();

27
tests/baselines/reference/functionsInClassExpressions.symbols Normal file
View file

@ -0,0 +1,27 @@
=== tests/cases/compiler/functionsInClassExpressions.ts ===
let Foo = class {
>Foo : Symbol(Foo, Decl(functionsInClassExpressions.ts, 0, 3))
constructor() {
this.bar++;
>this.bar : Symbol((Anonymous class).bar, Decl(functionsInClassExpressions.ts, 3, 5))
>this : Symbol((Anonymous class), Decl(functionsInClassExpressions.ts, 0, 9))
>bar : Symbol((Anonymous class).bar, Decl(functionsInClassExpressions.ts, 3, 5))
}
bar = 0;
>bar : Symbol((Anonymous class).bar, Decl(functionsInClassExpressions.ts, 3, 5))
inc = () => {
>inc : Symbol((Anonymous class).inc, Decl(functionsInClassExpressions.ts, 4, 12))
this.bar++;
>this.bar : Symbol((Anonymous class).bar, Decl(functionsInClassExpressions.ts, 3, 5))
>this : Symbol((Anonymous class), Decl(functionsInClassExpressions.ts, 0, 9))
>bar : Symbol((Anonymous class).bar, Decl(functionsInClassExpressions.ts, 3, 5))
}
m() { return this.bar; }
>m : Symbol((Anonymous class).m, Decl(functionsInClassExpressions.ts, 7, 5))
>this.bar : Symbol((Anonymous class).bar, Decl(functionsInClassExpressions.ts, 3, 5))
>this : Symbol((Anonymous class), Decl(functionsInClassExpressions.ts, 0, 9))
>bar : Symbol((Anonymous class).bar, Decl(functionsInClassExpressions.ts, 3, 5))
}

32
tests/baselines/reference/functionsInClassExpressions.types Normal file
View file

@ -0,0 +1,32 @@
=== tests/cases/compiler/functionsInClassExpressions.ts ===
let Foo = class {
>Foo : typeof (Anonymous class)
>class { constructor() { this.bar++; } bar = 0; inc = () => { this.bar++; } m() { return this.bar; }} : typeof (Anonymous class)
constructor() {
this.bar++;
>this.bar++ : number
>this.bar : number
>this : this
>bar : number
}
bar = 0;
>bar : number
>0 : number
inc = () => {
>inc : () => void
>() => { this.bar++; } : () => void
this.bar++;
>this.bar++ : number
>this.bar : number
>this : this
>bar : number
}
m() { return this.bar; }
>m : () => number
>this.bar : number
>this : this
>bar : number
}

12
tests/baselines/reference/multipleDefaultExports01.errors.txt
View file

@ -1,6 +1,6 @@
tests/cases/conformance/es6/modules/m1.ts(2,22): error TS2300: Duplicate identifier 'foo'.
tests/cases/conformance/es6/modules/m1.ts(6,25): error TS2300: Duplicate identifier 'bar'.
tests/cases/conformance/es6/modules/m1.ts(11,1): error TS2300: Duplicate identifier 'default'.
tests/cases/conformance/es6/modules/m1.ts(2,22): error TS2528: A module cannot have multiple default exports.
tests/cases/conformance/es6/modules/m1.ts(6,25): error TS2528: A module cannot have multiple default exports.
tests/cases/conformance/es6/modules/m1.ts(11,1): error TS2528: A module cannot have multiple default exports.
tests/cases/conformance/es6/modules/m2.ts(3,1): error TS2348: Value of type 'typeof foo' is not callable. Did you mean to include 'new'?
@ -8,20 +8,20 @@ tests/cases/conformance/es6/modules/m2.ts(3,1): error TS2348: Value of type 'typ
export default class foo {
~~~
!!! error TS2300: Duplicate identifier 'foo'.
!!! error TS2528: A module cannot have multiple default exports.
}
export default function bar() {
~~~
!!! error TS2300: Duplicate identifier 'bar'.
!!! error TS2528: A module cannot have multiple default exports.
}
var x = 10;
export default x;
~~~~~~~~~~~~~~~~~
!!! error TS2300: Duplicate identifier 'default'.
!!! error TS2528: A module cannot have multiple default exports.
==== tests/cases/conformance/es6/modules/m2.ts (1 errors) ====
import Entity from "./m1"

15
tests/baselines/reference/multipleDefaultExports03.errors.txt Normal file
View file

@ -0,0 +1,15 @@
tests/cases/conformance/es6/modules/multipleDefaultExports03.ts(2,22): error TS2528: A module cannot have multiple default exports.
tests/cases/conformance/es6/modules/multipleDefaultExports03.ts(5,22): error TS2528: A module cannot have multiple default exports.
==== tests/cases/conformance/es6/modules/multipleDefaultExports03.ts (2 errors) ====
export default class C {
~
!!! error TS2528: A module cannot have multiple default exports.
}
export default class C {
~
!!! error TS2528: A module cannot have multiple default exports.
}

23
tests/baselines/reference/multipleDefaultExports03.js Normal file
View file

@ -0,0 +1,23 @@
//// [multipleDefaultExports03.ts]
export default class C {
}
export default class C {
}
//// [multipleDefaultExports03.js]
var C = (function () {
function C() {
}
return C;
})();
Object.defineProperty(exports, "__esModule", { value: true });
exports.default = C;
var C = (function () {
function C() {
}
return C;
})();
Object.defineProperty(exports, "__esModule", { value: true });
exports.default = C;

15
tests/baselines/reference/multipleDefaultExports04.errors.txt Normal file
View file

@ -0,0 +1,15 @@
tests/cases/conformance/es6/modules/multipleDefaultExports04.ts(2,25): error TS2393: Duplicate function implementation.
tests/cases/conformance/es6/modules/multipleDefaultExports04.ts(5,25): error TS2393: Duplicate function implementation.
==== tests/cases/conformance/es6/modules/multipleDefaultExports04.ts (2 errors) ====
export default function f() {
~
!!! error TS2393: Duplicate function implementation.
}
export default function f() {
~
!!! error TS2393: Duplicate function implementation.
}

17
tests/baselines/reference/multipleDefaultExports04.js Normal file
View file

@ -0,0 +1,17 @@
//// [multipleDefaultExports04.ts]
export default function f() {
}
export default function f() {
}
//// [multipleDefaultExports04.js]
function f() {
}
Object.defineProperty(exports, "__esModule", { value: true });
exports.default = f;
function f() {
}
Object.defineProperty(exports, "__esModule", { value: true });
exports.default = f;

164
tests/baselines/reference/shorthandPropertyAssignmentsInDestructuring.errors.txt Normal file
View file

@ -0,0 +1,164 @@
tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring.ts(16,9): error TS2459: Type '{}' has no property 's1' and no string index signature.
tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring.ts(22,9): error TS2459: Type '{}' has no property 's1' and no string index signature.
tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring.ts(40,9): error TS2322: Type 'number' is not assignable to type 'string'.
tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring.ts(46,12): error TS2322: Type 'number' is not assignable to type 'string'.
tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring.ts(72,5): error TS2322: Type 'number' is not assignable to type 'string'.
tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring.ts(77,8): error TS2322: Type 'number' is not assignable to type 'string'.
tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring.ts(82,5): error TS2322: Type 'number' is not assignable to type 'string'.
tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring.ts(82,13): error TS2322: Type '{ x: number; }' is not assignable to type '{ x: string; }'.
Types of property 'x' are incompatible.
Type 'number' is not assignable to type 'string'.
tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring.ts(87,8): error TS2322: Type 'number' is not assignable to type 'string'.
tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring.ts(87,19): error TS2322: Type '{ x: number; }' is not assignable to type '{ x: string; }'.
Types of property 'x' are incompatible.
Type 'number' is not assignable to type 'string'.
tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring.ts(113,12): error TS2304: Cannot find name 's'.
tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring.ts(113,14): error TS1312: '=' can only be used in an object literal property inside a destructuring assignment.
==== tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring.ts (12 errors) ====
(function() {
var s0;
for ({ s0 = 5 } of [{ s0: 1 }]) {
}
});
(function() {
var s0;
for ({ s0:s0 = 5 } of [{ s0: 1 }]) {
}
});
(function() {
var s1;
for ({ s1 = 5 } of [{}]) {
~~
!!! error TS2459: Type '{}' has no property 's1' and no string index signature.
}
});
(function() {
var s1;
for ({ s1:s1 = 5 } of [{}]) {
~~
!!! error TS2459: Type '{}' has no property 's1' and no string index signature.
}
});
(function() {
var s2;
for ({ s2 = 5 } of [{ s2: "" }]) {
}
});
(function() {
var s2;
for ({ s2:s2 = 5 } of [{ s2: "" }]) {
}
});
(function() {
var s3: string;
for ({ s3 = 5 } of [{ s3: "" }]) {
~~
!!! error TS2322: Type 'number' is not assignable to type 'string'.
}
});
(function() {
var s3: string;
for ({ s3:s3 = 5 } of [{ s3: "" }]) {
~~
!!! error TS2322: Type 'number' is not assignable to type 'string'.
}
});
(function() {
let y;
({ y = 5 } = { y: 1 })
});
(function() {
let y;
({ y:y = 5 } = { y: 1 })
});
(function() {
let y0: number;
({ y0 = 5 } = { y0: 1 })
});
(function() {
let y0: number;
({ y0:y0 = 5 } = { y0: 1 })
});
(function() {
let y1: string;
({ y1 = 5 } = {})
~~
!!! error TS2322: Type 'number' is not assignable to type 'string'.
});
(function() {
let y1: string;
({ y1:y1 = 5 } = {})
~~
!!! error TS2322: Type 'number' is not assignable to type 'string'.
});
(function() {
let y2: string, y3: { x: string };
({ y2 = 5, y3 = { x: 1 } } = {})
~~
!!! error TS2322: Type 'number' is not assignable to type 'string'.
~~
!!! error TS2322: Type '{ x: number; }' is not assignable to type '{ x: string; }'.
!!! error TS2322: Types of property 'x' are incompatible.
!!! error TS2322: Type 'number' is not assignable to type 'string'.
});
(function() {
let y2: string, y3: { x: string };
({ y2:y2 = 5, y3:y3 = { x: 1 } } = {})
~~
!!! error TS2322: Type 'number' is not assignable to type 'string'.
~~
!!! error TS2322: Type '{ x: number; }' is not assignable to type '{ x: string; }'.
!!! error TS2322: Types of property 'x' are incompatible.
!!! error TS2322: Type 'number' is not assignable to type 'string'.
});
(function() {
let y4: number, y5: { x: number };
({ y4 = 5, y5 = { x: 1 } } = {})
});
(function() {
let y4: number, y5: { x: number };
({ y4:y4 = 5, y5:y5 = { x: 1 } } = {})
});
(function() {
let z;
({ z = { x: 5 } } = { z: { x: 1 } });
});
(function() {
let z;
({ z:z = { x: 5 } } = { z: { x: 1 } });
});
(function() {
let a = { s = 5 };
~
!!! error TS2304: Cannot find name 's'.
~
!!! error TS1312: '=' can only be used in an object literal property inside a destructuring assignment.
});
function foo({a = 4, b = { x: 5 }}) {
}

242
tests/baselines/reference/shorthandPropertyAssignmentsInDestructuring.js Normal file
View file

@ -0,0 +1,242 @@
//// [shorthandPropertyAssignmentsInDestructuring.ts]
(function() {
var s0;
for ({ s0 = 5 } of [{ s0: 1 }]) {
}
});
(function() {
var s0;
for ({ s0:s0 = 5 } of [{ s0: 1 }]) {
}
});
(function() {
var s1;
for ({ s1 = 5 } of [{}]) {
}
});
(function() {
var s1;
for ({ s1:s1 = 5 } of [{}]) {
}
});
(function() {
var s2;
for ({ s2 = 5 } of [{ s2: "" }]) {
}
});
(function() {
var s2;
for ({ s2:s2 = 5 } of [{ s2: "" }]) {
}
});
(function() {
var s3: string;
for ({ s3 = 5 } of [{ s3: "" }]) {
}
});
(function() {
var s3: string;
for ({ s3:s3 = 5 } of [{ s3: "" }]) {
}
});
(function() {
let y;
({ y = 5 } = { y: 1 })
});
(function() {
let y;
({ y:y = 5 } = { y: 1 })
});
(function() {
let y0: number;
({ y0 = 5 } = { y0: 1 })
});
(function() {
let y0: number;
({ y0:y0 = 5 } = { y0: 1 })
});
(function() {
let y1: string;
({ y1 = 5 } = {})
});
(function() {
let y1: string;
({ y1:y1 = 5 } = {})
});
(function() {
let y2: string, y3: { x: string };
({ y2 = 5, y3 = { x: 1 } } = {})
});
(function() {
let y2: string, y3: { x: string };
({ y2:y2 = 5, y3:y3 = { x: 1 } } = {})
});
(function() {
let y4: number, y5: { x: number };
({ y4 = 5, y5 = { x: 1 } } = {})
});
(function() {
let y4: number, y5: { x: number };
({ y4:y4 = 5, y5:y5 = { x: 1 } } = {})
});
(function() {
let z;
({ z = { x: 5 } } = { z: { x: 1 } });
});
(function() {
let z;
({ z:z = { x: 5 } } = { z: { x: 1 } });
});
(function() {
let a = { s = 5 };
});
function foo({a = 4, b = { x: 5 }}) {
}
//// [shorthandPropertyAssignmentsInDestructuring.js]
(function () {
var s0;
for (var _i = 0, _a = [{ s0: 1 }]; _i < _a.length; _i++) {
_b = _a[_i].s0, s0 = _b === void 0 ? 5 : _b;
}
var _b;
});
(function () {
var s0;
for (var _i = 0, _a = [{ s0: 1 }]; _i < _a.length; _i++) {
_b = _a[_i].s0, s0 = _b === void 0 ? 5 : _b;
}
var _b;
});
(function () {
var s1;
for (var _i = 0, _a = [{}]; _i < _a.length; _i++) {
_b = _a[_i].s1, s1 = _b === void 0 ? 5 : _b;
}
var _b;
});
(function () {
var s1;
for (var _i = 0, _a = [{}]; _i < _a.length; _i++) {
_b = _a[_i].s1, s1 = _b === void 0 ? 5 : _b;
}
var _b;
});
(function () {
var s2;
for (var _i = 0, _a = [{ s2: "" }]; _i < _a.length; _i++) {
_b = _a[_i].s2, s2 = _b === void 0 ? 5 : _b;
}
var _b;
});
(function () {
var s2;
for (var _i = 0, _a = [{ s2: "" }]; _i < _a.length; _i++) {
_b = _a[_i].s2, s2 = _b === void 0 ? 5 : _b;
}
var _b;
});
(function () {
var s3;
for (var _i = 0, _a = [{ s3: "" }]; _i < _a.length; _i++) {
_b = _a[_i].s3, s3 = _b === void 0 ? 5 : _b;
}
var _b;
});
(function () {
var s3;
for (var _i = 0, _a = [{ s3: "" }]; _i < _a.length; _i++) {
_b = _a[_i].s3, s3 = _b === void 0 ? 5 : _b;
}
var _b;
});
(function () {
var y;
(_a = { y: 1 }, _b = _a.y, y = _b === void 0 ? 5 : _b, _a);
var _a, _b;
});
(function () {
var y;
(_a = { y: 1 }, _b = _a.y, y = _b === void 0 ? 5 : _b, _a);
var _a, _b;
});
(function () {
var y0;
(_a = { y0: 1 }, _b = _a.y0, y0 = _b === void 0 ? 5 : _b, _a);
var _a, _b;
});
(function () {
var y0;
(_a = { y0: 1 }, _b = _a.y0, y0 = _b === void 0 ? 5 : _b, _a);
var _a, _b;
});
(function () {
var y1;
(_a = {}, _b = _a.y1, y1 = _b === void 0 ? 5 : _b, _a);
var _a, _b;
});
(function () {
var y1;
(_a = {}, _b = _a.y1, y1 = _b === void 0 ? 5 : _b, _a);
var _a, _b;
});
(function () {
var y2, y3;
(_a = {}, _b = _a.y2, y2 = _b === void 0 ? 5 : _b, _c = _a.y3, y3 = _c === void 0 ? { x: 1 } : _c, _a);
var _a, _b, _c;
});
(function () {
var y2, y3;
(_a = {}, _b = _a.y2, y2 = _b === void 0 ? 5 : _b, _c = _a.y3, y3 = _c === void 0 ? { x: 1 } : _c, _a);
var _a, _b, _c;
});
(function () {
var y4, y5;
(_a = {}, _b = _a.y4, y4 = _b === void 0 ? 5 : _b, _c = _a.y5, y5 = _c === void 0 ? { x: 1 } : _c, _a);
var _a, _b, _c;
});
(function () {
var y4, y5;
(_a = {}, _b = _a.y4, y4 = _b === void 0 ? 5 : _b, _c = _a.y5, y5 = _c === void 0 ? { x: 1 } : _c, _a);
var _a, _b, _c;
});
(function () {
var z;
(_a = { z: { x: 1 } }, _b = _a.z, z = _b === void 0 ? { x: 5 } : _b, _a);
var _a, _b;
});
(function () {
var z;
(_a = { z: { x: 1 } }, _b = _a.z, z = _b === void 0 ? { x: 5 } : _b, _a);
var _a, _b;
});
(function () {
var a = { s: s };
});
function foo(_a) {
var _b = _a.a, a = _b === void 0 ? 4 : _b, _c = _a.b, b = _c === void 0 ? { x: 5 } : _c;
}

164
tests/baselines/reference/shorthandPropertyAssignmentsInDestructuring_ES6.errors.txt Normal file
View file

@ -0,0 +1,164 @@
tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring_ES6.ts(16,9): error TS2459: Type '{}' has no property 's1' and no string index signature.
tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring_ES6.ts(22,9): error TS2459: Type '{}' has no property 's1' and no string index signature.
tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring_ES6.ts(40,9): error TS2322: Type 'number' is not assignable to type 'string'.
tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring_ES6.ts(46,12): error TS2322: Type 'number' is not assignable to type 'string'.
tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring_ES6.ts(72,5): error TS2322: Type 'number' is not assignable to type 'string'.
tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring_ES6.ts(77,8): error TS2322: Type 'number' is not assignable to type 'string'.
tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring_ES6.ts(82,5): error TS2322: Type 'number' is not assignable to type 'string'.
tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring_ES6.ts(82,13): error TS2322: Type '{ x: number; }' is not assignable to type '{ x: string; }'.
Types of property 'x' are incompatible.
Type 'number' is not assignable to type 'string'.
tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring_ES6.ts(87,8): error TS2322: Type 'number' is not assignable to type 'string'.
tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring_ES6.ts(87,19): error TS2322: Type '{ x: number; }' is not assignable to type '{ x: string; }'.
Types of property 'x' are incompatible.
Type 'number' is not assignable to type 'string'.
tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring_ES6.ts(113,12): error TS2304: Cannot find name 's'.
tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring_ES6.ts(113,14): error TS1312: '=' can only be used in an object literal property inside a destructuring assignment.
==== tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring_ES6.ts (12 errors) ====
(function() {
var s0;
for ({ s0 = 5 } of [{ s0: 1 }]) {
}
});
(function() {
var s0;
for ({ s0:s0 = 5 } of [{ s0: 1 }]) {
}
});
(function() {
var s1;
for ({ s1 = 5 } of [{}]) {
~~
!!! error TS2459: Type '{}' has no property 's1' and no string index signature.
}
});
(function() {
var s1;
for ({ s1:s1 = 5 } of [{}]) {
~~
!!! error TS2459: Type '{}' has no property 's1' and no string index signature.
}
});
(function() {
var s2;
for ({ s2 = 5 } of [{ s2: "" }]) {
}
});
(function() {
var s2;
for ({ s2:s2 = 5 } of [{ s2: "" }]) {
}
});
(function() {
var s3: string;
for ({ s3 = 5 } of [{ s3: "" }]) {
~~
!!! error TS2322: Type 'number' is not assignable to type 'string'.
}
});
(function() {
var s3: string;
for ({ s3:s3 = 5 } of [{ s3: "" }]) {
~~
!!! error TS2322: Type 'number' is not assignable to type 'string'.
}
});
(function() {
let y;
({ y = 5 } = { y: 1 })
});
(function() {
let y;
({ y:y = 5 } = { y: 1 })
});
(function() {
let y0: number;
({ y0 = 5 } = { y0: 1 })
});
(function() {
let y0: number;
({ y0:y0 = 5 } = { y0: 1 })
});
(function() {
let y1: string;
({ y1 = 5 } = {})
~~
!!! error TS2322: Type 'number' is not assignable to type 'string'.
});
(function() {
let y1: string;
({ y1:y1 = 5 } = {})
~~
!!! error TS2322: Type 'number' is not assignable to type 'string'.
});
(function() {
let y2: string, y3: { x: string };
({ y2 = 5, y3 = { x: 1 } } = {})
~~
!!! error TS2322: Type 'number' is not assignable to type 'string'.
~~
!!! error TS2322: Type '{ x: number; }' is not assignable to type '{ x: string; }'.
!!! error TS2322: Types of property 'x' are incompatible.
!!! error TS2322: Type 'number' is not assignable to type 'string'.
});
(function() {
let y2: string, y3: { x: string };
({ y2:y2 = 5, y3:y3 = { x: 1 } } = {})
~~
!!! error TS2322: Type 'number' is not assignable to type 'string'.
~~
!!! error TS2322: Type '{ x: number; }' is not assignable to type '{ x: string; }'.
!!! error TS2322: Types of property 'x' are incompatible.
!!! error TS2322: Type 'number' is not assignable to type 'string'.
});
(function() {
let y4: number, y5: { x: number };
({ y4 = 5, y5 = { x: 1 } } = {})
});
(function() {
let y4: number, y5: { x: number };
({ y4:y4 = 5, y5:y5 = { x: 1 } } = {})
});
(function() {
let z;
({ z = { x: 5 } } = { z: { x: 1 } });
});
(function() {
let z;
({ z:z = { x: 5 } } = { z: { x: 1 } });
});
(function() {
let a = { s = 5 };
~
!!! error TS2304: Cannot find name 's'.
~
!!! error TS1312: '=' can only be used in an object literal property inside a destructuring assignment.
});
function foo({a = 4, b = { x: 5 }}) {
}

213
tests/baselines/reference/shorthandPropertyAssignmentsInDestructuring_ES6.js Normal file
View file

@ -0,0 +1,213 @@
//// [shorthandPropertyAssignmentsInDestructuring_ES6.ts]
(function() {
var s0;
for ({ s0 = 5 } of [{ s0: 1 }]) {
}
});
(function() {
var s0;
for ({ s0:s0 = 5 } of [{ s0: 1 }]) {
}
});
(function() {
var s1;
for ({ s1 = 5 } of [{}]) {
}
});
(function() {
var s1;
for ({ s1:s1 = 5 } of [{}]) {
}
});
(function() {
var s2;
for ({ s2 = 5 } of [{ s2: "" }]) {
}
});
(function() {
var s2;
for ({ s2:s2 = 5 } of [{ s2: "" }]) {
}
});
(function() {
var s3: string;
for ({ s3 = 5 } of [{ s3: "" }]) {
}
});
(function() {
var s3: string;
for ({ s3:s3 = 5 } of [{ s3: "" }]) {
}
});
(function() {
let y;
({ y = 5 } = { y: 1 })
});
(function() {
let y;
({ y:y = 5 } = { y: 1 })
});
(function() {
let y0: number;
({ y0 = 5 } = { y0: 1 })
});
(function() {
let y0: number;
({ y0:y0 = 5 } = { y0: 1 })
});
(function() {
let y1: string;
({ y1 = 5 } = {})
});
(function() {
let y1: string;
({ y1:y1 = 5 } = {})
});
(function() {
let y2: string, y3: { x: string };
({ y2 = 5, y3 = { x: 1 } } = {})
});
(function() {
let y2: string, y3: { x: string };
({ y2:y2 = 5, y3:y3 = { x: 1 } } = {})
});
(function() {
let y4: number, y5: { x: number };
({ y4 = 5, y5 = { x: 1 } } = {})
});
(function() {
let y4: number, y5: { x: number };
({ y4:y4 = 5, y5:y5 = { x: 1 } } = {})
});
(function() {
let z;
({ z = { x: 5 } } = { z: { x: 1 } });
});
(function() {
let z;
({ z:z = { x: 5 } } = { z: { x: 1 } });
});
(function() {
let a = { s = 5 };
});
function foo({a = 4, b = { x: 5 }}) {
}
//// [shorthandPropertyAssignmentsInDestructuring_ES6.js]
(function () {
var s0;
for ({ s0 = 5 } of [{ s0: 1 }]) {
}
});
(function () {
var s0;
for ({ s0: s0 = 5 } of [{ s0: 1 }]) {
}
});
(function () {
var s1;
for ({ s1 = 5 } of [{}]) {
}
});
(function () {
var s1;
for ({ s1: s1 = 5 } of [{}]) {
}
});
(function () {
var s2;
for ({ s2 = 5 } of [{ s2: "" }]) {
}
});
(function () {
var s2;
for ({ s2: s2 = 5 } of [{ s2: "" }]) {
}
});
(function () {
var s3;
for ({ s3 = 5 } of [{ s3: "" }]) {
}
});
(function () {
var s3;
for ({ s3: s3 = 5 } of [{ s3: "" }]) {
}
});
(function () {
let y;
({ y = 5 } = { y: 1 });
});
(function () {
let y;
({ y: y = 5 } = { y: 1 });
});
(function () {
let y0;
({ y0 = 5 } = { y0: 1 });
});
(function () {
let y0;
({ y0: y0 = 5 } = { y0: 1 });
});
(function () {
let y1;
({ y1 = 5 } = {});
});
(function () {
let y1;
({ y1: y1 = 5 } = {});
});
(function () {
let y2, y3;
({ y2 = 5, y3 = { x: 1 } } = {});
});
(function () {
let y2, y3;
({ y2: y2 = 5, y3: y3 = { x: 1 } } = {});
});
(function () {
let y4, y5;
({ y4 = 5, y5 = { x: 1 } } = {});
});
(function () {
let y4, y5;
({ y4: y4 = 5, y5: y5 = { x: 1 } } = {});
});
(function () {
let z;
({ z = { x: 5 } } = { z: { x: 1 } });
});
(function () {
let z;
({ z: z = { x: 5 } } = { z: { x: 1 } });
});
(function () {
let a = { s = 5 };
});
function foo({ a = 4, b = { x: 5 } }) {
}

6
tests/baselines/reference/tsxReactEmit6.js
View file

@ -19,7 +19,11 @@ namespace M {
// and M.React.__spread
var foo;
var spread1 = <div x='' {...foo} y='' />;
// Quotes
var x = <div>This "quote" thing</div>;
}
//// [file.js]
@ -33,4 +37,6 @@ var M;
// and M.React.__spread
var foo;
var spread1 = M.React.createElement("div", M.React.__spread({x: ''}, foo, {y: ''}));
// Quotes
var x = M.React.createElement("div", null, "This \"quote\" thing");
})(M || (M = {}));

7
tests/baselines/reference/tsxReactEmit6.symbols
View file

@ -36,5 +36,12 @@ namespace M {
>x : Symbol(unknown)
>foo : Symbol(foo, Decl(react-consumer.tsx, 7, 4))
>y : Symbol(unknown)
// Quotes
var x = <div>This "quote" thing</div>;
>x : Symbol(x, Decl(react-consumer.tsx, 11, 4))
>div : Symbol(JSX.IntrinsicElements, Decl(file.tsx, 2, 22))
>div : Symbol(JSX.IntrinsicElements, Decl(file.tsx, 2, 22))
}

8
tests/baselines/reference/tsxReactEmit6.types
View file

@ -37,5 +37,13 @@ namespace M {
>x : any
>foo : any
>y : any
// Quotes
var x = <div>This "quote" thing</div>;
>x : JSX.Element
><div>This "quote" thing</div> : JSX.Element
>div : any
>div : any
}

29
tests/cases/compiler/constIndexedAccess.ts Normal file
View file

@ -0,0 +1,29 @@

const enum numbers {
zero,
one
}
interface indexAccess {
0: string;
1: number;
}
let test: indexAccess;
let s = test[0];
let n = test[1];
let s1 = test[numbers.zero];
let n1 = test[numbers.one];
let s2 = test[numbers["zero"]];
let n2 = test[numbers["one"]];
enum numbersNotConst {
zero,
one
}
let s3 = test[numbersNotConst.zero];
let n3 = test[numbersNotConst.one];

18
tests/cases/compiler/exportedBlockScopedDeclarations.ts Normal file
View file

@ -0,0 +1,18 @@
// @module: amd
const foo = foo; // compile error
export const bar = bar; // should be compile error
function f() {
const bar = bar; // compile error
}
namespace NS {
export const bar = bar; // should be compile error
}
let foo1 = foo1; // compile error
export let bar1 = bar1; // should be compile error
function f1() {
let bar1 = bar1; // compile error
}
namespace NS1 {
export let bar1 = bar1; // should be compile error
}

10
tests/cases/compiler/functionsInClassExpressions.ts Normal file
View file

@ -0,0 +1,10 @@
let Foo = class {
constructor() {
this.bar++;
}
bar = 0;
inc = () => {
this.bar++;
}
m() { return this.bar; }
}

118
tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring.ts Normal file
View file

@ -0,0 +1,118 @@
// @target: ES5
(function() {
var s0;
for ({ s0 = 5 } of [{ s0: 1 }]) {
}
});
(function() {
var s0;
for ({ s0:s0 = 5 } of [{ s0: 1 }]) {
}
});
(function() {
var s1;
for ({ s1 = 5 } of [{}]) {
}
});
(function() {
var s1;
for ({ s1:s1 = 5 } of [{}]) {
}
});
(function() {
var s2;
for ({ s2 = 5 } of [{ s2: "" }]) {
}
});
(function() {
var s2;
for ({ s2:s2 = 5 } of [{ s2: "" }]) {
}
});
(function() {
var s3: string;
for ({ s3 = 5 } of [{ s3: "" }]) {
}
});
(function() {
var s3: string;
for ({ s3:s3 = 5 } of [{ s3: "" }]) {
}
});
(function() {
let y;
({ y = 5 } = { y: 1 })
});
(function() {
let y;
({ y:y = 5 } = { y: 1 })
});
(function() {
let y0: number;
({ y0 = 5 } = { y0: 1 })
});
(function() {
let y0: number;
({ y0:y0 = 5 } = { y0: 1 })
});
(function() {
let y1: string;
({ y1 = 5 } = {})
});
(function() {
let y1: string;
({ y1:y1 = 5 } = {})
});
(function() {
let y2: string, y3: { x: string };
({ y2 = 5, y3 = { x: 1 } } = {})
});
(function() {
let y2: string, y3: { x: string };
({ y2:y2 = 5, y3:y3 = { x: 1 } } = {})
});
(function() {
let y4: number, y5: { x: number };
({ y4 = 5, y5 = { x: 1 } } = {})
});
(function() {
let y4: number, y5: { x: number };
({ y4:y4 = 5, y5:y5 = { x: 1 } } = {})
});
(function() {
let z;
({ z = { x: 5 } } = { z: { x: 1 } });
});
(function() {
let z;
({ z:z = { x: 5 } } = { z: { x: 1 } });
});
(function() {
let a = { s = 5 };
});
function foo({a = 4, b = { x: 5 }}) {
}

118
tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring_ES6.ts Normal file
View file

@ -0,0 +1,118 @@
// @target: ES6
(function() {
var s0;
for ({ s0 = 5 } of [{ s0: 1 }]) {
}
});
(function() {
var s0;
for ({ s0:s0 = 5 } of [{ s0: 1 }]) {
}
});
(function() {
var s1;
for ({ s1 = 5 } of [{}]) {
}
});
(function() {
var s1;
for ({ s1:s1 = 5 } of [{}]) {
}
});
(function() {
var s2;
for ({ s2 = 5 } of [{ s2: "" }]) {
}
});
(function() {
var s2;
for ({ s2:s2 = 5 } of [{ s2: "" }]) {
}
});
(function() {
var s3: string;
for ({ s3 = 5 } of [{ s3: "" }]) {
}
});
(function() {
var s3: string;
for ({ s3:s3 = 5 } of [{ s3: "" }]) {
}
});
(function() {
let y;
({ y = 5 } = { y: 1 })
});
(function() {
let y;
({ y:y = 5 } = { y: 1 })
});
(function() {
let y0: number;
({ y0 = 5 } = { y0: 1 })
});
(function() {
let y0: number;
({ y0:y0 = 5 } = { y0: 1 })
});
(function() {
let y1: string;
({ y1 = 5 } = {})
});
(function() {
let y1: string;
({ y1:y1 = 5 } = {})
});
(function() {
let y2: string, y3: { x: string };
({ y2 = 5, y3 = { x: 1 } } = {})
});
(function() {
let y2: string, y3: { x: string };
({ y2:y2 = 5, y3:y3 = { x: 1 } } = {})
});
(function() {
let y4: number, y5: { x: number };
({ y4 = 5, y5 = { x: 1 } } = {})
});
(function() {
let y4: number, y5: { x: number };
({ y4:y4 = 5, y5:y5 = { x: 1 } } = {})
});
(function() {
let z;
({ z = { x: 5 } } = { z: { x: 1 } });
});
(function() {
let z;
({ z:z = { x: 5 } } = { z: { x: 1 } });
});
(function() {
let a = { s = 5 };
});
function foo({a = 4, b = { x: 5 }}) {
}

7
tests/cases/conformance/es6/modules/defaultExportWithOverloads01.ts Normal file
View file

@ -0,0 +1,7 @@
// @module: commonjs
// @target: ES5
export default function f();
export default function f(x: string);
export default function f(...args: any[]) {
}

8
tests/cases/conformance/es6/modules/multipleDefaultExports03.ts Normal file
View file

@ -0,0 +1,8 @@
// @module: commonjs
// @target: ES5
export default class C {
}
export default class C {
}

8
tests/cases/conformance/es6/modules/multipleDefaultExports04.ts Normal file
View file

@ -0,0 +1,8 @@
// @module: commonjs
// @target: ES5
export default function f() {
}
export default function f() {
}

4
tests/cases/conformance/jsx/tsxReactEmit6.tsx
View file

@ -19,4 +19,8 @@ namespace M {
// and M.React.__spread
var foo;
var spread1 = <div x='' {...foo} y='' />;
// Quotes
var x = <div>This "quote" thing</div>;
}

13
tests/cases/fourslash/formatAsyncKeyword.ts Normal file
View file

@ -0,0 +1,13 @@
/// <reference path="fourslash.ts" />
/////*1*/let x = async () => 1;
/////*2*/let y = async() => 1;
/////*3*/let z = async function () { return 1; };
format.document();
goTo.marker("1");
verify.currentLineContentIs("let x = async () => 1;");
goTo.marker("2");
verify.currentLineContentIs("let y = async () => 1;");
goTo.marker("3");
verify.currentLineContentIs("let z = async function() { return 1; };")

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

@ -68,6 +68,13 @@ enum EmitReturnStatus {
EmitErrorsEncountered = 4 // Emitter errors occurred during emitting process
}
// This is a duplicate of the indentstyle in services.ts to expose it to testcases in fourslash
enum IndentStyle {
None,
Block,
Smart,
}
module FourSlashInterface {
export interface Marker {
@ -278,8 +285,8 @@ module FourSlashInterface {
FourSlash.currentTestState.verifyIndentationAtCurrentPosition(numberOfSpaces);
}
public indentationAtPositionIs(fileName: string, position: number, numberOfSpaces: number) {
FourSlash.currentTestState.verifyIndentationAtPosition(fileName, position, numberOfSpaces);
public indentationAtPositionIs(fileName: string, position: number, numberOfSpaces: number, indentStyle = IndentStyle.Smart) {
FourSlash.currentTestState.verifyIndentationAtPosition(fileName, position, numberOfSpaces, indentStyle);
}
public textAtCaretIs(text: string) {

183
tests/cases/fourslash/indentationBlock.ts Normal file
View file

@ -0,0 +1,183 @@
/// <reference path="fourslash.ts"/>
////
////module classes {
////{| "indent": 0 |}
//// class Bar {
////{| "indent": 4 |}
////
//// constructor() {
////{| "indent": 8 |}
//// }
////
//// private foo: string = "";
////{| "indent": 8 |}
////
//// private f() {
//// var a: any[] = [[1, 2], [3, 4], 5];
////{| "indent": 12 |}
//// return ((1 + 1));
//// }
////
////{| "indent": 8 |}
//// private f2() {
//// if (true) { } { };
//// }
//// }
////}
////
////
////module interfaces {
////{| "indent": 0 |}
//// interface Foo {
////{| "indent": 4 |}
////
//// x: number;
////{| "indent": 8 |}
////
//// foo(): number;
////{| "indent": 8 |}
//// }
////}
////
////
////module nestedModules {
//// module Foo2 {
////{| "indent": 4 |}
//// function f() {
//// }
////{| "indent": 8 |}
//// var x: number;
////{| "indent": 8 |}
//// }
////}
////
////
////module Enums {
//// enum Foo3 {
////{| "indent": 4 |}
//// val1,
////{| "indent": 8 |}
//// val2,
////{| "indent": 8 |}
//// }
////{| "indent": 4 |}
////}
////
////
////function controlStatements() {
//// for (var i = 0; i < 10; i++) {
////{| "indent": 4 |}
//// }
////
//// for (var e in foo.bar) {
////{| "indent": 4 |}
//// }
////
//// with (foo.bar) {
////{| "indent": 4 |}
//// }
////
//// while (false) {
////{| "indent": 4 |}
//// }
////
//// do {
////{| "indent": 4 |}
//// } while (false);
////
//// switch (foo.bar) {
////{| "indent": 4 |}
//// }
////
//// switch (foo.bar) {
////{| "indent": 4 |}
//// case 1:
////{| "indent": 8 |}
//// break;
//// default:
////{| "indent": 8 |}
//// break;
//// }
////}
////
////
////function tryCatch() {
////{| "indent": 0 |}
//// try {
////{| "indent": 4 |}
//// }
////{| "indent": 4 |}
//// catch (err) {
////{| "indent": 4 |}
//// }
////{| "indent": 4 |}
////}
////
////
////function tryFinally() {
////{| "indent": 0 |}
//// try {
////{| "indent": 4 |}
//// }
////{| "indent": 4 |}
//// finally {
////{| "indent": 4 |}
//// }
////{| "indent": 4 |}
////}
////
////
////function tryCatchFinally() {
////{| "indent": 0 |}
//// try {
////{| "indent": 4 |}
//// }
////{| "indent": 4 |}
//// catch (err) {
////{| "indent": 4 |}
//// }
////{| "indent": 4 |}
//// finally {
////{| "indent": 4 |}
//// }
////{| "indent": 4 |}
////}
////
////
////class indentBeforeCurly
////{| "indent": 0 |}
////{| "indent": 0 |}{
////{| "indent": 0 |}
////}
////
////
////function argumentsListIndentation(bar,
//// blah,
//// {| "indent": 13 |}
////);
////
////
////function blockIndentAfterIndentedParameter1(bar,
//// blah) {
////{| "indent": 13 |}
////}
////
////
////function blockIndentAfterIndentedParameter2(bar,
//// blah) {
//// if (foo) {
////{| "indent": 4 |}
//// }
////}
////
////
////// Note: Do not add more tests at the end of this file, as
////// the purpose of this test is to verity smart indent
////// works for unterminated function arguments at the end of a file.
////function unterminatedListIndentation(a,
////{| "indent": 0 |}
test.markers().forEach(marker => {
verify.indentationAtPositionIs(marker.fileName, marker.position, marker.data.indent, IndentStyle.Block);
});

183
tests/cases/fourslash/indentationNone.ts Normal file
View file

@ -0,0 +1,183 @@
/// <reference path="fourslash.ts"/>
////
////module classes {
////{| "indent": 0 |}
//// class Bar {
////{| "indent": 0 |}
////
//// constructor() {
////{| "indent": 0 |}
//// }
////
//// private foo: string = "";
////{| "indent": 0 |}
////
//// private f() {
//// var a: any[] = [[1, 2], [3, 4], 5];
////{| "indent": 0 |}
//// return ((1 + 1));
//// }
////
////{| "indent": 0 |}
//// private f2() {
//// if (true) { } { };
//// }
//// }
////}
////
////
////module interfaces {
////{| "indent": 0 |}
//// interface Foo {
////{| "indent": 0 |}
////
//// x: number;
////{| "indent": 0 |}
////
//// foo(): number;
////{| "indent": 0 |}
//// }
////}
////
////
////module nestedModules {
//// module Foo2 {
////{| "indent": 0 |}
//// function f() {
//// }
////{| "indent": 0 |}
//// var x: number;
////{| "indent": 0 |}
//// }
////}
////
////
////module Enums {
//// enum Foo3 {
////{| "indent": 0 |}
//// val1,
////{| "indent": 0 |}
//// val2,
////{| "indent": 0 |}
//// }
////{| "indent": 0 |}
////}
////
////
////function controlStatements() {
//// for (var i = 0; i < 10; i++) {
////{| "indent": 0 |}
//// }
////
//// for (var e in foo.bar) {
////{| "indent": 0 |}
//// }
////
//// with (foo.bar) {
////{| "indent": 0 |}
//// }
////
//// while (false) {
////{| "indent": 0 |}
//// }
////
//// do {
////{| "indent": 0 |}
//// } while (false);
////
//// switch (foo.bar) {
////{| "indent": 0 |}
//// }
////
//// switch (foo.bar) {
////{| "indent": 0 |}
//// case 1:
////{| "indent": 0 |}
//// break;
//// default:
////{| "indent": 0 |}
//// break;
//// }
////}
////
////
////function tryCatch() {
////{| "indent": 0 |}
//// try {
////{| "indent": 0 |}
//// }
////{| "indent": 0 |}
//// catch (err) {
////{| "indent": 0 |}
//// }
////{| "indent": 0 |}
////}
////
////
////function tryFinally() {
////{| "indent": 0 |}
//// try {
////{| "indent": 0 |}
//// }
////{| "indent": 0 |}
//// finally {
////{| "indent": 0 |}
//// }
////{| "indent": 0 |}
////}
////
////
////function tryCatchFinally() {
////{| "indent": 0 |}
//// try {
////{| "indent": 0 |}
//// }
////{| "indent": 0 |}
//// catch (err) {
////{| "indent": 0 |}
//// }
////{| "indent": 0 |}
//// finally {
////{| "indent": 0 |}
//// }
////{| "indent": 0 |}
////}
////
////
////class indentBeforeCurly
////{| "indent": 0 |}
////{| "indent": 0 |}{
////{| "indent": 0 |}
////}
////
////
////function argumentsListIndentation(bar,
//// blah,
//// {| "indent": 0 |}
////);
////
////
////function blockIndentAfterIndentedParameter1(bar,
//// blah) {
////{| "indent": 0 |}
////}
////
////
////function blockIndentAfterIndentedParameter2(bar,
//// blah) {
//// if (foo) {
////{| "indent": 0 |}
//// }
////}
////
////
////// Note: Do not add more tests at the end of this file, as
////// the purpose of this test is to verity smart indent
////// works for unterminated function arguments at the end of a file.
////function unterminatedListIndentation(a,
////{| "indent": 0 |}
test.markers().forEach(marker => {
verify.indentationAtPositionIs(marker.fileName, marker.position, marker.data.indent, IndentStyle.None);
});