├── tests ├── cases │ ├── compiler │ │ ├── bind2.ts │ │ ├── emptyFile.ts │ │ ├── emptyExpr.ts │ │ ├── separate1-1.ts │ │ ├── bom-utf8.ts │ │ ├── emptyEnum.ts │ │ ├── nullKeyword.ts │ │ ├── numberAsInLHS.ts │ │ ├── asiBreak.ts │ │ ├── logicalNotExpression1.ts │ │ ├── negativeZero.ts │ │ ├── propertyAccess4.ts │ │ ├── undeclaredVarEmit.ts │ │ ├── arrayLiteral1.ts │ │ ├── asiContinue.ts │ │ ├── binaryArithmatic1.ts │ │ ├── forIn2.ts │ │ ├── invalidUnicodeEscapeSequance3.ts │ │ ├── isLiteral1.ts │ │ ├── missingRequiredDeclare.d.ts │ │ ├── propertyAccess5.ts │ │ ├── typecheckCommaExpression.ts │ │ ├── ClassDeclaration24.ts │ │ ├── FunctionDeclaration3.ts │ │ ├── arrayLiteral2.ts │ │ ├── badArrayIndex.ts │ │ ├── binaryArithmatic2.ts │ │ ├── binaryArithmatic4.ts │ │ ├── objectLiteral1.ts │ │ ├── primitiveTypeAsClassName.ts │ │ ├── recursiveGenericSignatureInstantiation2.ts │ │ ├── recursiveObjectLiteral.ts │ │ ├── unknownTypeErrors.ts │ │ ├── ParameterList4.ts │ │ ├── arrowFunctionInExpressionStatement1.ts │ │ ├── breakNotInIterationOrSwitchStatement1.ts │ │ ├── breakTarget1.ts │ │ ├── continueNotInIterationStatement1.ts │ │ ├── doWhileLoop.ts │ │ ├── functionOverloads3.ts │ │ ├── indexWithoutParamType.ts │ │ ├── invalidSplice.ts │ │ ├── invalidUnicodeEscapeSequance.ts │ │ ├── invalidUnicodeEscapeSequance2.ts │ │ ├── moduleNoEmit.ts │ │ ├── newMissingIdentifier.ts │ │ ├── objectLiteral2.ts │ │ ├── parse2.ts │ │ ├── primitiveTypeAsmoduleName.ts │ │ ├── restParameterNotLast.ts │ │ ├── topLevelLambda3.ts │ │ ├── unaryOperators1.ts │ │ ├── unterminatedRegexAtEndOfSource1.ts │ │ ├── unterminatedStringLiteralWithBackslash1.ts │ │ ├── varArgWithNoParamName.ts │ │ ├── ClassDeclaration9.ts │ │ ├── InterfaceDeclaration8.ts │ │ ├── binaryArithmatic3.ts │ │ ├── contextualTyping1.ts │ │ ├── continueTarget1.ts │ │ ├── convertKeywords.ts │ │ ├── duplicateVariableDeclaration1.ts │ │ ├── primitiveTypeAsInterfaceName.ts │ │ ├── propertyAccess2.ts │ │ ├── propertyAccess6.ts │ │ ├── restArgMissingName.ts │ │ ├── slashBeforeVariableDeclaration1.ts │ │ ├── unicodeIdentifierName2.ts │ │ ├── voidConstructor.ts │ │ ├── ParameterList5.ts │ │ ├── asiAmbientFunctionDeclaration.ts │ │ ├── breakTarget6.ts │ │ ├── callOnClass.ts │ │ ├── class2.ts │ │ ├── contextualTyping34.ts │ │ ├── duplicateTypeParameters1.ts │ │ ├── emptyGenericParamList.ts │ │ ├── genericInference1.ts │ │ ├── isLiteral2.ts │ │ ├── numericMethodName1.ts │ │ ├── propertyAccess3.ts │ │ ├── randomSemicolons1.ts │ │ ├── thisKeyword.ts │ │ ├── undefinedTypeArgument1.ts │ │ ├── ArrowFunctionExpression1.ts │ │ ├── ClassDeclaration8.ts │ │ ├── FunctionDeclaration4.ts │ │ ├── assignmentToParenthesizedExpression1.ts │ │ ├── augmentArray.ts │ │ ├── class1.ts │ │ ├── commentsAtEndOfFile1.ts │ │ ├── constraintErrors1.ts │ │ ├── contextualTyping28.ts │ │ ├── contextualTyping31.ts │ │ ├── contextualTyping6.ts │ │ ├── debuggerEmit.ts │ │ ├── deprecatedBool.ts │ │ ├── emptyTypeArgumentList.ts │ │ ├── enumWithQuotedElementName1.ts │ │ ├── enumWithQuotedElementName2.ts │ │ ├── incompleteObjectLiteral1.ts │ │ ├── indexWithoutParamType2.ts │ │ ├── multiExtendsSplitInterfaces1.ts │ │ ├── primitiveTypeAsInterfaceNameGeneric.ts │ │ ├── propertyAccess7.ts │ │ ├── quotedPropertyName1.ts │ │ ├── strictMode4.ts │ │ ├── stringHasStringValuedNumericIndexer.ts │ │ ├── switchCases.ts │ │ ├── ExportAssignment7.ts │ │ ├── ExportAssignment8.ts │ │ ├── FunctionDeclaration7.ts │ │ ├── ParameterList13.ts │ │ ├── anyPlusAny1.ts │ │ ├── arguments.ts │ │ ├── assignToModule.ts │ │ ├── cannotInvokeNewOnIndexExpression.ts │ │ ├── classImplementsClass1.ts │ │ ├── classInheritence.ts │ │ ├── contextualTyping16.ts │ │ ├── contextualTyping2.ts │ │ ├── contextualTyping29.ts │ │ ├── contextualTyping3.ts │ │ ├── contextualTyping30.ts │ │ ├── contextualTyping35.ts │ │ ├── contextualTyping5.ts │ │ ├── contextualTyping7.ts │ │ ├── contextualTyping8.ts │ │ ├── continueInIterationStatement3.ts │ │ ├── continueTarget6.ts │ │ ├── duplicateLabel1.ts │ │ ├── emptyTypeArgumentListWithNew.ts │ │ ├── enumNegativeLiteral1.ts │ │ ├── enumWithParenthesizedInitializer1.ts │ │ ├── enumWithUnicodeEscape1.ts │ │ ├── es6ClassTest9.ts │ │ ├── exportAssignmentWithExportModifier.ts │ │ ├── forInStatement1.ts │ │ ├── functionCall1.ts │ │ ├── quotedFunctionName1.ts │ │ ├── redefineArray.ts │ │ ├── separate1-2.ts │ │ ├── sourceMap-EmptyFile1.ts │ │ ├── sourceMapValidationDebugger.ts │ │ ├── varAndFunctionShareName.ts │ │ ├── ClassDeclaration13.ts │ │ ├── ClassDeclaration21.ts │ │ ├── ambientEnumElementInitializer1.ts │ │ ├── ambientEnumElementInitializer4.ts │ │ ├── ambientEnumElementInitializer5.ts │ │ ├── breakInIterationOrSwitchStatement1.ts │ │ ├── breakInIterationOrSwitchStatement3.ts │ │ ├── breakTarget2.ts │ │ ├── castNewObjectBug.ts │ │ ├── catchClauseWithTypeAnnotation.ts │ │ ├── classMethodWithKeywordName1.ts │ │ ├── classOverloadForFunction.ts │ │ ├── classOverloadForFunction2.ts │ │ ├── contextualTyping13.ts │ │ ├── contextualTyping37.ts │ │ ├── continueInIterationStatement1.ts │ │ ├── deleteOperatorInStrictMode.ts │ │ ├── enumGenericTypeClash.ts │ │ ├── exportAssignmentWithDeclareModifier.ts │ │ ├── forInStatement2.ts │ │ ├── functionCall15.ts │ │ ├── functionCall2.ts │ │ ├── functionCall3.ts │ │ ├── globalThis.ts │ │ ├── indirectSelfReference.ts │ │ ├── libdtsFix.ts │ │ ├── moduleRedifinitionErrors.ts │ │ ├── parse1.ts │ │ ├── quotedFunctionName2.ts │ │ ├── quotedPropertyName2.ts │ │ ├── sourceMap-SingleSpace1.ts │ │ ├── staticIndexer.ts │ │ ├── strictMode1.ts │ │ ├── topLevelLambda4.ts │ │ ├── undeclaredBase.ts │ │ ├── ClassDeclaration10.ts │ │ ├── ClassDeclaration14.ts │ │ ├── ClassDeclaration22.ts │ │ ├── arrowFunctionInExpressionStatement2.ts │ │ ├── classAndInterface1.ts │ │ ├── contextualTyping11.ts │ │ ├── contextualTyping21.ts │ │ ├── contextualTyping38.ts │ │ ├── contextualTyping9.ts │ │ ├── continueTarget2.ts │ │ ├── forInStatement4.ts │ │ ├── instantiateTypeParameter.ts │ │ ├── memberAccessOnConstructorType.ts │ │ ├── propertyAccess1.ts │ │ ├── quotedAccessorName1.ts │ │ ├── recursiveBaseCheck4.ts │ │ ├── restParamAsOptional.ts │ │ ├── sourceMap-Comment1.ts │ │ ├── sourceMap-NewLine1.ts │ │ ├── sourceMap-SemiColon1.ts │ │ ├── sourceMapValidationLabeled.ts │ │ ├── thisInModule.ts │ │ ├── topLevelLambda.ts │ │ ├── topLevelLambda2.ts │ │ ├── unresolvedTypeAssertionSymbol.ts │ │ ├── ClassDeclaration11.ts │ │ ├── ClassDeclaration15.ts │ │ ├── ambientEnumElementInitializer2.ts │ │ ├── ambientEnumElementInitializer3.ts │ │ ├── arrayReferenceWithoutTypeArgs.ts │ │ ├── breakInIterationOrSwitchStatement2.ts │ │ ├── collisionThisExpressionAndVarInGlobal.ts │ │ ├── commentOnExpressionStatement1.ts │ │ ├── conditionalExpression1.ts │ │ ├── contextualTyping10.ts │ │ ├── contextualTyping17.ts │ │ ├── contextualTyping18.ts │ │ ├── contextualTyping19.ts │ │ ├── contextualTyping25.ts │ │ ├── contextualTyping26.ts │ │ ├── contextualTyping27.ts │ │ ├── contextualTyping39.ts │ │ ├── contextualTyping4.ts │ │ ├── continueInIterationStatement2.ts │ │ ├── continueInIterationStatement4.ts │ │ ├── debugger.ts │ │ ├── enumWithPrimitiveName.ts │ │ ├── forInStatement5.ts │ │ ├── forInStatement6.ts │ │ ├── forInStatement7.ts │ │ ├── genericArrayAssignment1.ts │ │ ├── genericCallWithNonGenericArgs1.ts │ │ ├── nameCollisionsInPropertyAssignments.ts │ │ ├── newNonReferenceType.ts │ │ ├── noCollisionThisExpressionAndVarInGlobal.ts │ │ ├── numLit.ts │ │ ├── quotedAccessorName2.ts │ │ ├── quotedModuleNameMustBeAmbient.ts │ │ ├── recursiveFunctionTypes1.ts │ │ ├── recursiveTypeParameterConstraintReferenceLacksTypeArgs.ts │ │ ├── typeParametersInStaticProperties.ts │ │ ├── uncaughtCompilerError2.ts │ │ ├── FunctionDeclaration6.ts │ │ ├── MemberAccessorDeclaration15.ts │ │ ├── ParameterList6.ts │ │ ├── ambientModules.ts │ │ ├── breakInIterationOrSwitchStatement4.ts │ │ ├── breakTarget3.ts │ │ ├── breakTarget4.ts │ │ ├── collisionThisExpressionAndClassInGlobal.ts │ │ ├── commentOnIfStatement1.ts │ │ ├── contextualTyping36.ts │ │ ├── continueLabel.ts │ │ ├── dontShowCompilerGeneratedMembers.ts │ │ ├── enumCodeGenNewLines1.ts │ │ ├── enumsWithMultipleDeclarations3.ts │ │ ├── errorTypesAsTypeArguments.ts │ │ ├── exportAssignmentWithDeclareAndExportModifiers.ts │ │ ├── functionOverloads4.ts │ │ ├── idInProp.ts │ │ ├── interfaceNaming1.ts │ │ ├── modKeyword.ts │ │ ├── nestedGenerics.ts │ │ ├── overloadOnConstAsTypeAnnotation.ts │ │ ├── recursiveBaseCheck6.ts │ │ ├── thisExpressionInIndexExpression.ts │ │ ├── typeInferenceFixEarly.ts │ │ ├── typeParameterAsBaseClass.ts │ │ ├── voidOperator1.ts │ │ ├── arrayConcatMap.ts │ │ ├── autoAsiForStaticsInClassDeclaration.ts │ │ ├── classExtendsMultipleBaseClasses.ts │ │ ├── commentInEmptyParameterList1.ts │ │ ├── contextualTyping12.ts │ │ ├── contextualTyping14.ts │ │ ├── contextualTyping20.ts │ │ ├── contextualTyping40.ts │ │ ├── continueNotInIterationStatement3.ts │ │ ├── continueTarget3.ts │ │ ├── continueTarget4.ts │ │ ├── crashOnMethodSignatures.ts │ │ ├── duplicateConstructSignature.ts │ │ ├── duplicateLocalVariable4.ts │ │ ├── duplicateTypeParameters3.ts │ │ ├── emptyMemberAccess.ts │ │ ├── externFunc.ts │ │ ├── externSemantics.ts │ │ ├── forInModule.ts │ │ ├── functionOverloads1.ts │ │ ├── functionOverloads11.ts │ │ ├── genericArrayMethods1.ts │ │ ├── genericCallWithoutArgs.ts │ │ ├── indexIntoEnum.ts │ │ ├── indirectSelfReferenceGeneric.ts │ │ ├── inheritFromGenericTypeParameter.ts │ │ ├── mismatchedClassConstructorVariable.ts │ │ ├── moduleCodeGenTest3.ts │ │ ├── noCollisionThisExpressionAndClassInGlobal.ts │ │ ├── noImplicitAnyStringIndexerOnObject.ts │ │ ├── numberOnLeftSideOfInExpression.ts │ │ ├── objectLiteralDeclarationGeneration1.ts │ │ ├── optionalSetterParam.ts │ │ ├── parameterPropertyOutsideConstructor.ts │ │ ├── recursiveInheritanceGeneric.ts │ │ ├── staticAndMemberFunctions.ts │ │ ├── staticInstanceResolution4.ts │ │ ├── strictMode2.ts │ │ ├── typeOfOperator1.ts │ │ ├── typeofUnknownSymbol.ts │ │ ├── validRegexp.ts │ │ ├── ambientClassDeclarationWithExtends.ts │ │ ├── ambientClassOverloadForFunction.ts │ │ ├── catch.ts │ │ ├── classHeritageWithTrailingSeparator.ts │ │ ├── compoundVarDecl1.ts │ │ ├── constructorArgsErrors1.ts │ │ ├── contextualTyping41.ts │ │ ├── defaultValueInFunctionOverload1.ts │ │ ├── duplicateInterfaceMembers1.ts │ │ ├── duplicatePropertiesInStrictMode.ts │ │ ├── errorLocationForInterfaceExtension.ts │ │ ├── exportSameNameFuncVar.ts │ │ ├── getterMissingReturnError.ts │ │ ├── implementClausePrecedingExtends.ts │ │ ├── interfaceWithImplements1.ts │ │ ├── invalidReferenceSyntax1.ts │ │ ├── moduleWithValuesAsType.ts │ │ ├── numericIndexerConstraint.ts │ │ ├── objectLitStructuralTypeMismatch.ts │ │ ├── prefixIncrementAsOperandOfPlusExpression.ts │ │ ├── primitiveTypeAssignment.ts │ │ ├── propertyAccessibility2.ts │ │ ├── redeclarationOfVarWithGenericType.ts │ │ ├── sourceMapValidationFunctionPropertyAssignment.ts │ │ ├── typeofEnum.ts │ │ ├── ambientFundule.ts │ │ ├── assignmentCompat1.ts │ │ ├── classIndexer.ts │ │ ├── constructorArgsErrors5.ts │ │ ├── contextualTyping22.ts │ │ ├── duplicateLabel2.ts │ │ ├── duplicateLabel4.ts │ │ ├── enumWithoutInitializerAfterComputedMember.ts │ │ ├── forInStatement3.ts │ │ ├── functionOnlyHasThrow.ts │ │ ├── functionOverloads5.ts │ │ ├── genericFunctionHasFreshTypeArgs.ts │ │ ├── genericTypeUsedWithoutTypeArguments1.ts │ │ ├── illegalModifiersOnClassElements.ts │ │ ├── incompleteDottedExpressionAtEOF.ts │ │ ├── invalidStaticField.ts │ │ ├── newOnInstanceSymbol.ts │ │ ├── noTypeArgumentOnReturnType1.ts │ │ ├── optionalParamReferencingOtherParams3.ts │ │ ├── recursiveGenericSignatureInstantiation.ts │ │ ├── simpleArrowFunctionParameterReferencedInObjectLiteral1.ts │ │ ├── stringIndexerAndConstructor1.ts │ │ ├── typeParameterAsElementType.ts │ │ ├── variableDeclarator1.ts │ │ ├── ambientEnumElementInitializer6.ts │ │ ├── cannotInvokeNewOnErrorExpression.ts │ │ ├── collisionCodeGenEnumWithEnumMemberConflict.ts │ │ ├── commentOnStaticMember1.ts │ │ ├── contextualTyping23.ts │ │ ├── contextuallyTypingOrOperator3.ts │ │ ├── continueNotInIterationStatement2.ts │ │ ├── declFileForVarList.ts │ │ ├── declFileOptionalInterfaceMethod.ts │ │ ├── duplicateConstructSignature2.ts │ │ ├── exportAssignmentWithExports.ts │ │ ├── functionAssignmentError.ts │ │ ├── functionOverloads17.ts │ │ ├── functionReturningItself.ts │ │ ├── genericTypeUsedWithoutTypeArguments3.ts │ │ ├── i3.ts │ │ ├── interface0.ts │ │ ├── interfaceWithOptionalProperty.ts │ │ ├── mergedEnumDeclarationCodeGen.ts │ │ ├── moduleKeywordRepeatError.ts │ │ ├── nestedIndexer.ts │ │ ├── noSelfOnVars.ts │ │ ├── recursiveBaseCheck3.ts │ │ ├── recursiveGetterAccess.ts │ │ ├── staticMethodsReferencingClassTypeParameters.ts │ │ ├── stringLiteralPropertyNameWithLineContinuation1.ts │ │ ├── thisInConstructorParameter1.ts │ │ ├── toStringOnPrimitives.ts │ │ ├── typeVal.ts │ │ └── badOverloadError.ts │ ├── conformance │ │ ├── parser │ │ │ ├── ecmascript5 │ │ │ │ ├── parserEmptyFile1.ts │ │ │ │ ├── Fuzz │ │ │ │ │ └── parser768531.ts │ │ │ │ ├── TupleTypes │ │ │ │ │ ├── TupleType3.ts │ │ │ │ │ ├── TupleType4.ts │ │ │ │ │ ├── TupleType1.ts │ │ │ │ │ ├── TupleType5.ts │ │ │ │ │ └── TupleType2.ts │ │ │ │ ├── parserDebuggerStatement1.ts │ │ │ │ ├── parserUnicode3.ts │ │ │ │ ├── parserVoidExpression1.ts │ │ │ │ ├── Expressions │ │ │ │ │ ├── parserUnaryExpression6.ts │ │ │ │ │ ├── parserUnaryExpression1.ts │ │ │ │ │ ├── parserUnaryExpression3.ts │ │ │ │ │ ├── parserUnaryExpression4.ts │ │ │ │ │ ├── parserUnaryExpression7.ts │ │ │ │ │ ├── parserObjectCreation2.ts │ │ │ │ │ ├── parserPostfixPostfixExpression1.ts │ │ │ │ │ ├── parserPostfixUnaryExpression1.ts │ │ │ │ │ ├── parserUnaryExpression2.ts │ │ │ │ │ ├── parserUnaryExpression5.ts │ │ │ │ │ ├── parserAssignmentExpression1.ts │ │ │ │ │ ├── parserMemberAccessAfterPostfixExpression1.ts │ │ │ │ │ └── parserTypeAssertionInObjectCreationExpression1.ts │ │ │ │ ├── Generics │ │ │ │ │ ├── parserAmbiguity2.ts │ │ │ │ │ ├── parserAmbiguity1.ts │ │ │ │ │ ├── parserAmbiguity3.ts │ │ │ │ │ ├── parserConstructorAmbiguity1.ts │ │ │ │ │ ├── parserConstructorAmbiguity2.ts │ │ │ │ │ ├── parserConstructorAmbiguity3.ts │ │ │ │ │ ├── parserGenericClass1.ts │ │ │ │ │ ├── parserGenericClass2.ts │ │ │ │ │ ├── parserGreaterThanTokenAmbiguity1.ts │ │ │ │ │ ├── parserGreaterThanTokenAmbiguity11.ts │ │ │ │ │ ├── parserGreaterThanTokenAmbiguity12.ts │ │ │ │ │ ├── parserGreaterThanTokenAmbiguity16.ts │ │ │ │ │ ├── parserGreaterThanTokenAmbiguity17.ts │ │ │ │ │ ├── parserGreaterThanTokenAmbiguity2.ts │ │ │ │ │ ├── parserGreaterThanTokenAmbiguity3.ts │ │ │ │ │ ├── parserGreaterThanTokenAmbiguity6.ts │ │ │ │ │ ├── parserGreaterThanTokenAmbiguity7.ts │ │ │ │ │ ├── parserConstructorAmbiguity4.ts │ │ │ │ │ ├── parserGreaterThanTokenAmbiguity13.ts │ │ │ │ │ ├── parserGreaterThanTokenAmbiguity14.ts │ │ │ │ │ ├── parserGreaterThanTokenAmbiguity18.ts │ │ │ │ │ ├── parserGreaterThanTokenAmbiguity19.ts │ │ │ │ │ ├── parserGreaterThanTokenAmbiguity4.ts │ │ │ │ │ ├── parserGreaterThanTokenAmbiguity8.ts │ │ │ │ │ ├── parserGreaterThanTokenAmbiguity9.ts │ │ │ │ │ ├── parserGenericConstraint1.ts │ │ │ │ │ ├── parserGenericConstraint2.ts │ │ │ │ │ ├── parserGenericConstraint3.ts │ │ │ │ │ ├── parserGenericConstraint4.ts │ │ │ │ │ ├── parserGenericConstraint5.ts │ │ │ │ │ ├── parserGenericConstraint6.ts │ │ │ │ │ ├── parserGenericConstraint7.ts │ │ │ │ │ ├── parserMemberAccessOffOfGenericType1.ts │ │ │ │ │ └── parserObjectCreation1.ts │ │ │ │ ├── MissingTokens │ │ │ │ │ ├── parserMissingToken2.ts │ │ │ │ │ └── parserMissingToken1.ts │ │ │ │ ├── SkippedTokens │ │ │ │ │ ├── parserSkippedTokens1.ts │ │ │ │ │ ├── parserSkippedTokens2.ts │ │ │ │ │ ├── parserSkippedTokens12.ts │ │ │ │ │ ├── parserSkippedTokens18.ts │ │ │ │ │ ├── parserSkippedTokens3.ts │ │ │ │ │ ├── parserSkippedTokens11.ts │ │ │ │ │ ├── parserSkippedTokens13.ts │ │ │ │ │ ├── parserSkippedTokens17.ts │ │ │ │ │ ├── parserSkippedTokens20.ts │ │ │ │ │ ├── parserSkippedTokens4.ts │ │ │ │ │ ├── parserSkippedTokens5.ts │ │ │ │ │ ├── parserSkippedTokens6.ts │ │ │ │ │ ├── parserSkippedTokens19.ts │ │ │ │ │ ├── parserSkippedTokens7.ts │ │ │ │ │ ├── parserSkippedTokens8.ts │ │ │ │ │ ├── parserSkippedTokens10.ts │ │ │ │ │ ├── parserSkippedTokens15.ts │ │ │ │ │ ├── parserSkippedTokens9.ts │ │ │ │ │ └── parserSkippedTokens14.ts │ │ │ │ ├── Statements │ │ │ │ │ ├── parserBlockStatement1.d.ts │ │ │ │ │ ├── parserEmptyStatement1.d.ts │ │ │ │ │ ├── parserBreakStatement1.d.ts │ │ │ │ │ ├── parserReturnStatement1.d.ts │ │ │ │ │ ├── parserThrowStatement1.d.ts │ │ │ │ │ ├── parserContinueStatement1.d.ts │ │ │ │ │ ├── parserDebuggerStatement1.d.ts │ │ │ │ │ ├── parserExpressionStatement1.d.ts │ │ │ │ │ ├── parserIfStatement2.ts │ │ │ │ │ ├── parserVariableStatement1.d.ts │ │ │ │ │ ├── parserVariableStatement2.d.ts │ │ │ │ │ ├── parserDoStatement2.ts │ │ │ │ │ ├── parserForStatement1.d.ts │ │ │ │ │ ├── parserForStatement5.ts │ │ │ │ │ ├── parserIfStatement1.d.ts │ │ │ │ │ ├── parserWhileStatement1.d.ts │ │ │ │ │ ├── parserWithStatement1.d.ts │ │ │ │ │ ├── ReturnStatements │ │ │ │ │ │ ├── parserReturnStatement1.ts │ │ │ │ │ │ └── parserReturnStatement2.ts │ │ │ │ │ ├── parserForInStatement2.ts │ │ │ │ │ ├── parserForStatement4.ts │ │ │ │ │ ├── parserForStatement6.ts │ │ │ │ │ ├── parserForStatement8.ts │ │ │ │ │ ├── parserLabeledStatement1.d.ts │ │ │ │ │ ├── parserSwitchStatement1.d.ts │ │ │ │ │ ├── parserWithStatement2.ts │ │ │ │ │ ├── parserDoStatement1.d.ts │ │ │ │ │ ├── parserForInStatement1.d.ts │ │ │ │ │ ├── parserForInStatement3.ts │ │ │ │ │ ├── parserForInStatement4.ts │ │ │ │ │ ├── parserForStatement3.ts │ │ │ │ │ ├── parserForStatement7.ts │ │ │ │ │ ├── parserForInStatement5.ts │ │ │ │ │ ├── parserForInStatement6.ts │ │ │ │ │ ├── parserTryStatement1.d.ts │ │ │ │ │ ├── BreakStatements │ │ │ │ │ │ ├── parser_breakNotInIterationOrSwitchStatement1.ts │ │ │ │ │ │ └── parser_breakTarget1.ts │ │ │ │ │ └── ContinueStatements │ │ │ │ │ │ └── parser_continueNotInIterationStatement1.ts │ │ │ │ ├── Types │ │ │ │ │ ├── parserTypeQuery1.ts │ │ │ │ │ ├── parserTypeQuery2.ts │ │ │ │ │ ├── parserTypeQuery3.ts │ │ │ │ │ ├── parserTypeQuery4.ts │ │ │ │ │ ├── parserTypeQuery5.ts │ │ │ │ │ ├── parserTypeQuery6.ts │ │ │ │ │ ├── parserTypeQuery7.ts │ │ │ │ │ ├── parserTypeQuery8.ts │ │ │ │ │ └── parserTypeQuery9.ts │ │ │ │ ├── parserDebuggerStatement2.ts │ │ │ │ ├── ObjectTypes │ │ │ │ │ ├── parserObjectType1.ts │ │ │ │ │ ├── parserObjectType2.ts │ │ │ │ │ ├── parserObjectType3.ts │ │ │ │ │ ├── parserObjectType4.ts │ │ │ │ │ ├── parserObjectType5.ts │ │ │ │ │ └── parserObjectType6.ts │ │ │ │ ├── parservoidInQualifiedName0.ts │ │ │ │ ├── parservoidInQualifiedName1.ts │ │ │ │ ├── parservoidInQualifiedName2.ts │ │ │ │ ├── Protected │ │ │ │ │ ├── Protected1.ts │ │ │ │ │ ├── Protected2.ts │ │ │ │ │ ├── Protected3.ts │ │ │ │ │ ├── Protected4.ts │ │ │ │ │ ├── Protected5.ts │ │ │ │ │ ├── Protected6.ts │ │ │ │ │ ├── Protected7.ts │ │ │ │ │ ├── Protected8.ts │ │ │ │ │ └── Protected9.ts │ │ │ │ ├── RegressionTests │ │ │ │ │ ├── parser512084.ts │ │ │ │ │ ├── parser521128.ts │ │ │ │ │ ├── parser566700.ts │ │ │ │ │ ├── parser579071.ts │ │ │ │ │ ├── parser645086_1.ts │ │ │ │ │ ├── parser645086_2.ts │ │ │ │ │ ├── parser645086_3.ts │ │ │ │ │ ├── parser645086_4.ts │ │ │ │ │ ├── parser509677.ts │ │ │ │ │ ├── parser596700.ts │ │ │ │ │ ├── parser512325.ts │ │ │ │ │ ├── parser537152.ts │ │ │ │ │ ├── parser645484.ts │ │ │ │ │ ├── parser509693.ts │ │ │ │ │ ├── parserTernaryAndCommaOperators1.ts │ │ │ │ │ ├── parser509546.ts │ │ │ │ │ ├── parser509546_1.ts │ │ │ │ │ ├── parser509669.ts │ │ │ │ │ └── parser643728.ts │ │ │ │ ├── StrictMode │ │ │ │ │ ├── parserStrictMode3-negative.ts │ │ │ │ │ ├── parserStrictMode6-negative.ts │ │ │ │ │ ├── parserStrictMode15.ts │ │ │ │ │ ├── parserStrictMode3.ts │ │ │ │ │ ├── parserStrictMode5.ts │ │ │ │ │ ├── parserStrictMode6.ts │ │ │ │ │ ├── parserStrictMode7.ts │ │ │ │ │ ├── octalLiteralInStrictModeES3.ts │ │ │ │ │ ├── parserStrictMode4.ts │ │ │ │ │ ├── parserStrictMode14.ts │ │ │ │ │ ├── parserStrictMode15-negative.ts │ │ │ │ │ ├── parserStrictMode8.ts │ │ │ │ │ ├── parserStrictMode1.ts │ │ │ │ │ ├── parserStrictMode10.ts │ │ │ │ │ ├── parserStrictMode12.ts │ │ │ │ │ ├── parserStrictMode11.ts │ │ │ │ │ └── parserStrictMode9.ts │ │ │ │ ├── parserAdditiveExpression1.ts │ │ │ │ ├── parserObjectCreationArrayLiteral1.ts │ │ │ │ ├── parserObjectCreationArrayLiteral2.ts │ │ │ │ ├── parserObjectCreationArrayLiteral3.ts │ │ │ │ ├── parserObjectCreationArrayLiteral4.ts │ │ │ │ ├── ErrorRecovery │ │ │ │ │ ├── parserPublicBreak1.ts │ │ │ │ │ ├── parserFuzz1.ts │ │ │ │ │ ├── parserEqualsGreaterThanAfterFunction1.ts │ │ │ │ │ ├── ArgumentLists │ │ │ │ │ │ ├── parserErrorRecovery_ArgumentList6.ts │ │ │ │ │ │ └── parserErrorRecovery_ArgumentList7.ts │ │ │ │ │ ├── Expressions │ │ │ │ │ │ └── parserErrorRecovery_Expression1.ts │ │ │ │ │ ├── TypeArgumentLists │ │ │ │ │ │ ├── TypeArgumentList1.ts │ │ │ │ │ │ └── parserX_TypeArgumentList1.ts │ │ │ │ │ ├── parserEqualsGreaterThanAfterFunction2.ts │ │ │ │ │ ├── ArrowFunctions │ │ │ │ │ │ ├── ArrowFunction3.ts │ │ │ │ │ │ ├── ArrowFunction1.ts │ │ │ │ │ │ ├── ArrowFunction2.ts │ │ │ │ │ │ └── ArrowFunction4.ts │ │ │ │ │ ├── parserErrantEqualsGreaterThanAfterFunction1.ts │ │ │ │ │ ├── ParameterLists │ │ │ │ │ │ └── parserErrorRecovery_ParameterList5.ts │ │ │ │ │ ├── VariableLists │ │ │ │ │ │ ├── parserErrorRecovery_VariableList1.ts │ │ │ │ │ │ ├── parserVariableStatement1.ts │ │ │ │ │ │ └── parserVariableStatement2.ts │ │ │ │ │ ├── parserCommaInTypeMemberList1.ts │ │ │ │ │ └── parserErrantEqualsGreaterThanAfterFunction2.ts │ │ │ │ ├── ExportAssignments │ │ │ │ │ ├── parserExportAssignment3.ts │ │ │ │ │ ├── parserExportAssignment4.ts │ │ │ │ │ ├── parserExportAssignment1.ts │ │ │ │ │ ├── parserExportAssignment2.ts │ │ │ │ │ └── parserExportAssignment5.ts │ │ │ │ ├── VariableDeclarations │ │ │ │ │ ├── parserVariableDeclaration6.ts │ │ │ │ │ ├── parserVariableDeclaration8.ts │ │ │ │ │ ├── parserVariableDeclaration10.ts │ │ │ │ │ ├── parserVariableDeclaration11.ts │ │ │ │ │ ├── parserVariableDeclaration5.ts │ │ │ │ │ ├── parserVariableDeclaration7.ts │ │ │ │ │ ├── parserVariableDeclaration9.ts │ │ │ │ │ └── parserVariableDeclaration4.d.ts │ │ │ │ ├── EnumDeclarations │ │ │ │ │ ├── parserEnumDeclaration4.ts │ │ │ │ │ ├── parserEnum7.ts │ │ │ │ │ ├── parserEnum6.ts │ │ │ │ │ ├── parserEnumDeclaration2.d.ts │ │ │ │ │ ├── parserEnumDeclaration3.d.ts │ │ │ │ │ ├── parserEnumDeclaration3.ts │ │ │ │ │ └── parserEnumDeclaration1.ts │ │ │ │ ├── ParameterLists │ │ │ │ │ ├── parserParameterList11.ts │ │ │ │ │ ├── parserParameterList12.ts │ │ │ │ │ ├── parserParameterList4.ts │ │ │ │ │ ├── parserParameterList2.ts │ │ │ │ │ ├── parserParameterList3.ts │ │ │ │ │ ├── parserParameterList1.ts │ │ │ │ │ ├── parserParameterList5.ts │ │ │ │ │ ├── parserParameterList9.ts │ │ │ │ │ ├── parserParameterList10.ts │ │ │ │ │ └── parserParameterList13.ts │ │ │ │ ├── parserEmptyStatement1.ts │ │ │ │ ├── parserInExpression1.ts │ │ │ │ ├── parserUnicodeWhitespaceCharacter1.ts │ │ │ │ ├── ClassDeclarations │ │ │ │ │ ├── parserClassDeclaration24.ts │ │ │ │ │ ├── parserClassDeclaration23.ts │ │ │ │ │ ├── parserClassDeclaration7.d.ts │ │ │ │ │ ├── parserClassDeclaration6.ts │ │ │ │ │ ├── parserClassDeclaration9.ts │ │ │ │ │ ├── parserClassDeclaration1.ts │ │ │ │ │ ├── parserClassDeclaration3.ts │ │ │ │ │ └── parserClassDeclaration8.ts │ │ │ │ ├── FunctionDeclarations │ │ │ │ │ ├── parserFunctionDeclaration3.ts │ │ │ │ │ ├── parserFunctionDeclaration1.d.ts │ │ │ │ │ ├── parserFunctionDeclaration2.d.ts │ │ │ │ │ └── parserFunctionDeclaration2.ts │ │ │ │ ├── ModuleDeclarations │ │ │ │ │ ├── parserModuleDeclaration2.d.ts │ │ │ │ │ ├── parserModuleDeclaration1.d.ts │ │ │ │ │ ├── parserModuleDeclaration1.ts │ │ │ │ │ ├── parserModuleDeclaration6.ts │ │ │ │ │ ├── parserModuleDeclaration7.ts │ │ │ │ │ ├── parserModuleDeclaration8.ts │ │ │ │ │ ├── parserModuleDeclaration12.ts │ │ │ │ │ ├── parserModuleDeclaration2.ts │ │ │ │ │ ├── parserModuleDeclaration3.d.ts │ │ │ │ │ └── parserModuleDeclaration9.ts │ │ │ │ ├── ObjectLiterals │ │ │ │ │ └── parserObjectLiterals1.ts │ │ │ │ ├── ArrayLiteralExpressions │ │ │ │ │ ├── parserArrayLiteralExpression1.ts │ │ │ │ │ ├── parserArrayLiteralExpression2.ts │ │ │ │ │ ├── parserArrayLiteralExpression3.ts │ │ │ │ │ ├── parserArrayLiteralExpression4.ts │ │ │ │ │ ├── parserArrayLiteralExpression5.ts │ │ │ │ │ ├── parserArrayLiteralExpression6.ts │ │ │ │ │ ├── parserArrayLiteralExpression7.ts │ │ │ │ │ ├── parserArrayLiteralExpression8.ts │ │ │ │ │ ├── parserArrayLiteralExpression9.ts │ │ │ │ │ ├── parserArrayLiteralExpression10.ts │ │ │ │ │ ├── parserArrayLiteralExpression11.ts │ │ │ │ │ ├── parserArrayLiteralExpression12.ts │ │ │ │ │ ├── parserArrayLiteralExpression13.ts │ │ │ │ │ ├── parserArrayLiteralExpression14.ts │ │ │ │ │ └── parserArrayLiteralExpression15.ts │ │ │ │ ├── RegularExpressions │ │ │ │ │ ├── parserRegularExpression3.ts │ │ │ │ │ ├── parserRegularExpression2.ts │ │ │ │ │ ├── parserRegularExpressionDivideAmbiguity4.ts │ │ │ │ │ ├── parserRegularExpressionDivideAmbiguity2.ts │ │ │ │ │ └── parserRegularExpressionDivideAmbiguity3.ts │ │ │ │ ├── Accessors │ │ │ │ │ ├── parserAccessors8.ts │ │ │ │ │ ├── parserAccessors3.ts │ │ │ │ │ ├── parserAccessors4.ts │ │ │ │ │ ├── parserAccessors9.ts │ │ │ │ │ └── parserAccessors7.ts │ │ │ │ ├── IndexSignatures │ │ │ │ │ ├── parserIndexSignature1.ts │ │ │ │ │ ├── parserIndexSignature3.ts │ │ │ │ │ ├── parserIndexSignature4.ts │ │ │ │ │ ├── parserIndexSignature5.ts │ │ │ │ │ ├── parserIndexSignature2.ts │ │ │ │ │ ├── parserIndexSignature6.ts │ │ │ │ │ ├── parserIndexSignature7.ts │ │ │ │ │ ├── parserIndexSignature9.ts │ │ │ │ │ └── parserIndexSignature10.ts │ │ │ │ ├── MethodSignatures │ │ │ │ │ ├── parserMethodSignature1.ts │ │ │ │ │ ├── parserMethodSignature2.ts │ │ │ │ │ ├── parserMethodSignature9.ts │ │ │ │ │ ├── parserMethodSignature10.ts │ │ │ │ │ ├── parserMethodSignature11.ts │ │ │ │ │ ├── parserMethodSignature12.ts │ │ │ │ │ ├── parserMethodSignature3.ts │ │ │ │ │ ├── parserMethodSignature4.ts │ │ │ │ │ ├── parserMethodSignature5.ts │ │ │ │ │ ├── parserMethodSignature6.ts │ │ │ │ │ ├── parserMethodSignature7.ts │ │ │ │ │ └── parserMethodSignature8.ts │ │ │ │ ├── ArrowFunctionExpressions │ │ │ │ │ ├── parserArrowFunctionExpression2.ts │ │ │ │ │ ├── parserArrowFunctionExpression3.ts │ │ │ │ │ └── parserArrowFunctionExpression4.ts │ │ │ │ ├── InterfaceDeclarations │ │ │ │ │ ├── parserInterfaceDeclaration3.ts │ │ │ │ │ ├── parserInterfaceDeclaration4.ts │ │ │ │ │ ├── parserInterfaceDeclaration5.ts │ │ │ │ │ ├── parserInterfaceDeclaration7.ts │ │ │ │ │ ├── parserInterfaceDeclaration8.ts │ │ │ │ │ └── parserInterfaceDeclaration2.ts │ │ │ │ ├── PropertyAssignments │ │ │ │ │ ├── parserFunctionPropertyAssignment1.ts │ │ │ │ │ ├── parserFunctionPropertyAssignment2.ts │ │ │ │ │ ├── parserFunctionPropertyAssignment3.ts │ │ │ │ │ └── parserFunctionPropertyAssignment4.ts │ │ │ │ ├── PropertySignatures │ │ │ │ │ ├── parserPropertySignature1.ts │ │ │ │ │ ├── parserPropertySignature10.ts │ │ │ │ │ ├── parserPropertySignature2.ts │ │ │ │ │ ├── parserPropertySignature3.ts │ │ │ │ │ ├── parserPropertySignature5.ts │ │ │ │ │ ├── parserPropertySignature6.ts │ │ │ │ │ ├── parserPropertySignature9.ts │ │ │ │ │ ├── parserPropertySignature11.ts │ │ │ │ │ ├── parserPropertySignature12.ts │ │ │ │ │ ├── parserPropertySignature4.ts │ │ │ │ │ ├── parserPropertySignature7.ts │ │ │ │ │ └── parserPropertySignature8.ts │ │ │ │ └── parserImportDeclaration1.ts │ │ │ └── ecmascript3 │ │ │ │ └── Accessors │ │ │ │ ├── parserES3Accessors3.ts │ │ │ │ ├── parserES3Accessors4.ts │ │ │ │ ├── parserES3Accessors1.ts │ │ │ │ └── parserES3Accessors2.ts │ │ ├── scanner │ │ │ ├── ecmascript3 │ │ │ │ ├── scannerES3NumericLiteral1.ts │ │ │ │ ├── scannerES3NumericLiteral2.ts │ │ │ │ ├── scannerES3NumericLiteral3.ts │ │ │ │ ├── scannerES3NumericLiteral4.ts │ │ │ │ ├── scannerES3NumericLiteral5.ts │ │ │ │ ├── scannerES3NumericLiteral6.ts │ │ │ │ └── scannerES3NumericLiteral7.ts │ │ │ └── ecmascript5 │ │ │ │ ├── scannerUnexpectedNullCharacter1.ts │ │ │ │ ├── scannerNumericLiteral1.ts │ │ │ │ ├── scannerNumericLiteral2.ts │ │ │ │ ├── scannerNumericLiteral4.ts │ │ │ │ ├── scannerNumericLiteral5.ts │ │ │ │ ├── scannerNumericLiteral6.ts │ │ │ │ ├── scannerNumericLiteral8.ts │ │ │ │ ├── scannerNumericLiteral9.ts │ │ │ │ ├── scannerAdditiveExpression1.ts │ │ │ │ ├── scannerNumericLiteral3.ts │ │ │ │ ├── scannerNumericLiteral7.ts │ │ │ │ ├── scannerUnicodeEscapeInKeyword1.ts │ │ │ │ ├── scannerStringLiteralWithContainingNullCharacter1.ts │ │ │ │ └── scannerImportDeclaration1.ts │ │ ├── types │ │ │ ├── primitives │ │ │ │ ├── null │ │ │ │ │ └── directReferenceToNull.ts │ │ │ │ ├── void │ │ │ │ │ └── validVoidValues.ts │ │ │ │ ├── undefined │ │ │ │ │ ├── validUndefinedValues.ts │ │ │ │ │ └── directReferenceToUndefined.ts │ │ │ │ └── boolean │ │ │ │ │ └── boolInsteadOfBoolean.ts │ │ │ └── typeRelationships │ │ │ │ └── assignmentCompatibility │ │ │ │ └── assignmentCompatWithWithGenericConstructSignatures.ts │ │ ├── statements │ │ │ └── throwStatements │ │ │ │ └── invalidThrowStatement.ts │ │ └── ambient │ │ │ └── ambientExternalModuleInsideNonAmbient.ts │ ├── projects │ │ ├── declareVariableCollision │ │ │ ├── in1.d.ts │ │ │ └── in2.d.ts │ │ ├── moduleMergeOrder │ │ │ └── b.ts │ │ ├── NestedLocalModule-SimpleCase │ │ │ └── test2.ts │ │ ├── non-relative │ │ │ ├── lib │ │ │ │ ├── bar │ │ │ │ │ └── a.ts │ │ │ │ └── foo │ │ │ │ │ ├── b.ts │ │ │ │ │ └── a.ts │ │ │ └── decl.ts │ │ ├── RelativePaths │ │ │ ├── app.ts │ │ │ ├── b.ts │ │ │ └── A │ │ │ │ ├── a.ts │ │ │ │ └── b.ts │ │ ├── ext-int-ext │ │ │ ├── internal.ts │ │ │ └── external2.ts │ │ ├── baseline │ │ │ ├── emit.ts │ │ │ └── dont_emit.ts │ │ ├── NoModule │ │ │ └── foo │ │ │ │ └── bar.ts │ │ ├── reference-path-static │ │ │ └── lib.ts │ │ ├── ModuleIdentifier │ │ │ ├── decl.ts │ │ │ └── consume.ts │ │ ├── privacyCheck-IndirectReference │ │ │ ├── indirectExternalModule.ts │ │ │ └── test.ts │ │ ├── relative-nested │ │ │ └── app.ts │ │ ├── DeclareExportAdded │ │ │ └── ref.d.ts │ │ ├── relative-global-ref │ │ │ └── decl.d.ts │ │ ├── relative-nested-ref │ │ │ └── decl.d.ts │ │ └── No-default-lib │ │ │ └── test.ts │ ├── unittests │ │ └── services │ │ │ └── formatting │ │ │ └── testCode │ │ │ ├── formatting │ │ │ ├── emptyBlock.ts │ │ │ ├── emptyBlockBaseline.ts │ │ │ ├── onSemiColon.ts │ │ │ ├── onSemiColonBaseline.ts │ │ │ ├── implicitModuleBaseline.ts │ │ │ └── spaceAfterConstructorBaseline.ts │ │ │ └── testCode │ │ │ └── formatting │ │ │ ├── emptyBlock.ts │ │ │ ├── emptyBlockBaseline.ts │ │ │ ├── onSemiColon.ts │ │ │ └── onSemiColonBaseline.ts │ ├── fourslash │ │ ├── generated │ │ │ └── dummy.txt │ │ ├── todoComments13.ts │ │ ├── todoComments1.ts │ │ ├── todoComments2.ts │ │ ├── todoComments4.ts │ │ ├── todoComments14.ts │ │ ├── todoComments3.ts │ │ └── todoComments15.ts │ └── fourslash_old │ │ ├── todoComments1.ts │ │ ├── todoComments13.ts │ │ ├── todoComments2.ts │ │ ├── todoComments14.ts │ │ └── todoComments4.ts └── baselines │ └── reference │ ├── project │ ├── declarationsCascadingImports │ │ ├── amd │ │ │ └── useModule.js │ │ └── node │ │ │ └── useModule.js │ ├── outModuleSimpleSpecifyOutputFile │ │ ├── amd │ │ │ └── bin │ │ │ │ ├── test.js │ │ │ │ └── test.d.ts │ │ └── node │ │ │ └── bin │ │ │ ├── test.js │ │ │ └── test.d.ts │ ├── visibilityOfTypeUsedAcrossModules │ │ └── node │ │ │ ├── server.js │ │ │ └── commands.js │ ├── outModuleMultifolderSpecifyOutputFile │ │ ├── amd │ │ │ └── bin │ │ │ │ ├── test.js │ │ │ │ └── test.d.ts │ │ └── node │ │ │ └── bin │ │ │ ├── test.js │ │ │ └── test.d.ts │ ├── outModuleSubfolderSpecifyOutputFile │ │ ├── amd │ │ │ └── bin │ │ │ │ ├── test.d.ts │ │ │ │ └── test.js │ │ └── node │ │ │ └── bin │ │ │ ├── test.d.ts │ │ │ └── test.js │ ├── baseline2 │ │ └── node │ │ │ └── dont_emit.js │ ├── maprootUrlModuleSimpleSpecifyOutputFile │ │ ├── amd │ │ │ └── bin │ │ │ │ └── test.d.ts │ │ └── node │ │ │ └── bin │ │ │ └── test.d.ts │ ├── sourcemapModuleSimpleSpecifyOutputFile │ │ ├── amd │ │ │ └── bin │ │ │ │ ├── test.d.ts │ │ │ │ └── test.js │ │ └── node │ │ │ └── bin │ │ │ ├── test.d.ts │ │ │ └── test.js │ ├── sourcemapModuleSubfolderSpecifyOutputFile │ │ ├── amd │ │ │ └── bin │ │ │ │ ├── test.d.ts │ │ │ │ └── test.js │ │ └── node │ │ │ └── bin │ │ │ ├── test.d.ts │ │ │ └── test.js │ ├── maprootUrlModuleMultifolderSpecifyOutputFile │ │ ├── amd │ │ │ └── bin │ │ │ │ └── test.d.ts │ │ └── node │ │ │ └── bin │ │ │ └── test.d.ts │ ├── maprootUrlModuleSubfolderSpecifyOutputFile │ │ ├── amd │ │ │ └── bin │ │ │ │ └── test.d.ts │ │ └── node │ │ │ └── bin │ │ │ └── test.d.ts │ ├── sourcemapModuleMultifolderSpecifyOutputFile │ │ ├── amd │ │ │ └── bin │ │ │ │ ├── test.d.ts │ │ │ │ └── test.js │ │ └── node │ │ │ └── bin │ │ │ ├── test.d.ts │ │ │ └── test.js │ ├── sourcerootUrlModuleSimpleSpecifyOutputFile │ │ ├── amd │ │ │ └── bin │ │ │ │ ├── test.d.ts │ │ │ │ └── test.js │ │ └── node │ │ │ └── bin │ │ │ ├── test.d.ts │ │ │ └── test.js │ ├── sourcerootUrlModuleSubfolderSpecifyOutputFile │ │ ├── amd │ │ │ └── bin │ │ │ │ ├── test.d.ts │ │ │ │ └── test.js │ │ └── node │ │ │ └── bin │ │ │ ├── test.d.ts │ │ │ └── test.js │ ├── mapRootAbsolutePathModuleSimpleSpecifyOutputFile │ │ ├── amd │ │ │ └── bin │ │ │ │ └── test.d.ts │ │ └── node │ │ │ └── bin │ │ │ └── test.d.ts │ ├── mapRootAbsolutePathModuleSubfolderSpecifyOutputFile │ │ ├── amd │ │ │ └── bin │ │ │ │ └── test.d.ts │ │ └── node │ │ │ └── bin │ │ │ └── test.d.ts │ ├── mapRootRelativePathModuleSimpleSpecifyOutputFile │ │ ├── amd │ │ │ └── bin │ │ │ │ └── test.d.ts │ │ └── node │ │ │ └── bin │ │ │ └── test.d.ts │ ├── mapRootRelativePathModuleSubfolderSpecifyOutputFile │ │ ├── amd │ │ │ └── bin │ │ │ │ └── test.d.ts │ │ └── node │ │ │ └── bin │ │ │ └── test.d.ts │ ├── sourceRootAbsolutePathModuleSimpleSpecifyOutputFile │ │ ├── amd │ │ │ └── bin │ │ │ │ ├── test.d.ts │ │ │ │ └── test.js │ │ └── node │ │ │ └── bin │ │ │ └── test.d.ts │ ├── sourceRootRelativePathModuleSimpleSpecifyOutputFile │ │ ├── amd │ │ │ └── bin │ │ │ │ ├── test.d.ts │ │ │ │ └── test.js │ │ └── node │ │ │ └── bin │ │ │ └── test.d.ts │ ├── sourcerootUrlModuleMultifolderSpecifyOutputFile │ │ ├── amd │ │ │ └── bin │ │ │ │ ├── test.d.ts │ │ │ │ └── test.js │ │ └── node │ │ │ └── bin │ │ │ ├── test.d.ts │ │ │ └── test.js │ ├── mapRootAbsolutePathModuleMultifolderSpecifyOutputFile │ │ ├── amd │ │ │ └── bin │ │ │ │ └── test.d.ts │ │ └── node │ │ │ └── bin │ │ │ └── test.d.ts │ ├── mapRootRelativePathModuleMultifolderSpecifyOutputFile │ │ ├── amd │ │ │ └── bin │ │ │ │ └── test.d.ts │ │ └── node │ │ │ └── bin │ │ │ └── test.d.ts │ ├── maprootUrlsourcerootUrlModuleSimpleSpecifyOutputFile │ │ ├── amd │ │ │ └── bin │ │ │ │ └── test.d.ts │ │ └── node │ │ │ └── bin │ │ │ └── test.d.ts │ ├── maprootUrlsourcerootUrlModuleSubfolderSpecifyOutputFile │ │ ├── amd │ │ │ └── bin │ │ │ │ └── test.d.ts │ │ └── node │ │ │ └── bin │ │ │ └── test.d.ts │ ├── sourceRootAbsolutePathModuleMultifolderSpecifyOutputFile │ │ ├── amd │ │ │ └── bin │ │ │ │ └── test.d.ts │ │ └── node │ │ │ └── bin │ │ │ └── test.d.ts │ ├── sourceRootAbsolutePathModuleSubfolderSpecifyOutputFile │ │ ├── amd │ │ │ └── bin │ │ │ │ └── test.d.ts │ │ └── node │ │ │ └── bin │ │ │ └── test.d.ts │ ├── sourceRootRelativePathModuleMultifolderSpecifyOutputFile │ │ ├── amd │ │ │ └── bin │ │ │ │ └── test.d.ts │ │ └── node │ │ │ └── bin │ │ │ └── test.d.ts │ ├── sourceRootRelativePathModuleSubfolderSpecifyOutputFile │ │ ├── amd │ │ │ └── bin │ │ │ │ └── test.d.ts │ │ └── node │ │ │ └── bin │ │ │ └── test.d.ts │ ├── maprootUrlsourcerootUrlModuleMultifolderSpecifyOutputFile │ │ ├── amd │ │ │ └── bin │ │ │ │ └── test.d.ts │ │ └── node │ │ │ └── bin │ │ │ └── test.d.ts │ ├── baseline │ │ └── node │ │ │ └── emit.js │ └── nonRelative │ │ └── node │ │ └── lib │ │ ├── bar │ │ └── a.js │ │ └── foo │ │ ├── a.js │ │ └── b.js │ ├── bind2.js │ ├── emptyFile.js │ ├── emptyExpr.js │ ├── bind2.types │ ├── emptyEnum.types │ ├── getEmitOutputWithSyntaxErrors.baseline │ ├── parserEmptyFile1.js │ ├── bom-utf8.js │ ├── bom-utf8.types │ ├── emptyFile.types │ ├── separate1-1.js │ ├── TupleType1.js │ ├── bom-utf16be.types │ ├── bom-utf16le.types │ └── nullKeyword.js ├── bin └── tsc ├── doc ├── header.md └── spec.md ├── .npmignore └── src ├── lib └── importcore.d.ts └── services └── syntax └── languageVersion.ts /tests/cases/compiler/bind2.ts: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /tests/cases/compiler/emptyFile.ts: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /tests/cases/compiler/emptyExpr.ts: -------------------------------------------------------------------------------- 1 | [{},] -------------------------------------------------------------------------------- /tests/cases/compiler/separate1-1.ts: -------------------------------------------------------------------------------- 1 | X.f(); -------------------------------------------------------------------------------- /tests/cases/compiler/bom-utf8.ts: -------------------------------------------------------------------------------- 1 | var x=10; 2 | -------------------------------------------------------------------------------- /tests/cases/compiler/emptyEnum.ts: -------------------------------------------------------------------------------- 1 | enum E { 2 | } -------------------------------------------------------------------------------- /tests/cases/compiler/nullKeyword.ts: -------------------------------------------------------------------------------- 1 | null.foo; -------------------------------------------------------------------------------- /tests/cases/compiler/numberAsInLHS.ts: -------------------------------------------------------------------------------- 1 | 3 in [0, 1] -------------------------------------------------------------------------------- /tests/cases/compiler/asiBreak.ts: -------------------------------------------------------------------------------- 1 | while (true) break -------------------------------------------------------------------------------- /tests/cases/compiler/logicalNotExpression1.ts: -------------------------------------------------------------------------------- 1 | !foo; -------------------------------------------------------------------------------- /tests/cases/compiler/negativeZero.ts: -------------------------------------------------------------------------------- 1 | var x = -0 2 | -------------------------------------------------------------------------------- /tests/cases/compiler/propertyAccess4.ts: -------------------------------------------------------------------------------- 1 | null.toBAZ(); -------------------------------------------------------------------------------- /tests/cases/compiler/undeclaredVarEmit.ts: -------------------------------------------------------------------------------- 1 | f: number; -------------------------------------------------------------------------------- /bin/tsc: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env node 2 | require('./tsc.js') 3 | -------------------------------------------------------------------------------- /doc/header.md: -------------------------------------------------------------------------------- 1 | # TypeScript Language Specification 2 | 3 | -------------------------------------------------------------------------------- /tests/cases/compiler/arrayLiteral1.ts: -------------------------------------------------------------------------------- 1 | var v30 = [1, 2]; -------------------------------------------------------------------------------- /tests/cases/compiler/asiContinue.ts: -------------------------------------------------------------------------------- 1 | while (true) continue -------------------------------------------------------------------------------- /tests/cases/compiler/binaryArithmatic1.ts: -------------------------------------------------------------------------------- 1 | var v = 4 | null; -------------------------------------------------------------------------------- /tests/cases/compiler/forIn2.ts: -------------------------------------------------------------------------------- 1 | for (var i in 1) { 2 | } -------------------------------------------------------------------------------- /tests/cases/compiler/invalidUnicodeEscapeSequance3.ts: -------------------------------------------------------------------------------- 1 | a\u -------------------------------------------------------------------------------- /tests/cases/compiler/isLiteral1.ts: -------------------------------------------------------------------------------- 1 | var x: number = 02343; -------------------------------------------------------------------------------- /tests/cases/compiler/missingRequiredDeclare.d.ts: -------------------------------------------------------------------------------- 1 | var x = 1; -------------------------------------------------------------------------------- /tests/cases/compiler/propertyAccess5.ts: -------------------------------------------------------------------------------- 1 | undefined.toBAZ(); -------------------------------------------------------------------------------- /tests/cases/compiler/typecheckCommaExpression.ts: -------------------------------------------------------------------------------- 1 | (a, b) -------------------------------------------------------------------------------- /.npmignore: -------------------------------------------------------------------------------- 1 | built 2 | doc 3 | src 4 | tests 5 | Jakefile 6 | -------------------------------------------------------------------------------- /tests/cases/compiler/ClassDeclaration24.ts: -------------------------------------------------------------------------------- 1 | class any { 2 | } -------------------------------------------------------------------------------- /tests/cases/compiler/FunctionDeclaration3.ts: -------------------------------------------------------------------------------- 1 | function foo(); -------------------------------------------------------------------------------- /tests/cases/compiler/arrayLiteral2.ts: -------------------------------------------------------------------------------- 1 | var v30 = [1, 2], v31; -------------------------------------------------------------------------------- /tests/cases/compiler/badArrayIndex.ts: -------------------------------------------------------------------------------- 1 | var results = number[]; -------------------------------------------------------------------------------- /tests/cases/compiler/binaryArithmatic2.ts: -------------------------------------------------------------------------------- 1 | var v = 4 | undefined; -------------------------------------------------------------------------------- /tests/cases/compiler/binaryArithmatic4.ts: -------------------------------------------------------------------------------- 1 | var v = null | null; -------------------------------------------------------------------------------- /tests/cases/compiler/objectLiteral1.ts: -------------------------------------------------------------------------------- 1 | var v30 = {a:1, b:2}; -------------------------------------------------------------------------------- /tests/cases/compiler/primitiveTypeAsClassName.ts: -------------------------------------------------------------------------------- 1 | class any {} -------------------------------------------------------------------------------- /tests/cases/compiler/recursiveGenericSignatureInstantiation2.ts: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /tests/cases/compiler/recursiveObjectLiteral.ts: -------------------------------------------------------------------------------- 1 | var a = { f: a }; -------------------------------------------------------------------------------- /tests/cases/compiler/unknownTypeErrors.ts: -------------------------------------------------------------------------------- 1 | var foo: Unknown = 0; -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/parserEmptyFile1.ts: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /src/lib/importcore.d.ts: -------------------------------------------------------------------------------- 1 | /// 2 | -------------------------------------------------------------------------------- /tests/cases/compiler/ParameterList4.ts: -------------------------------------------------------------------------------- 1 | function F(public A) { 2 | } -------------------------------------------------------------------------------- /tests/cases/compiler/arrowFunctionInExpressionStatement1.ts: -------------------------------------------------------------------------------- 1 | () => 0; -------------------------------------------------------------------------------- /tests/cases/compiler/breakNotInIterationOrSwitchStatement1.ts: -------------------------------------------------------------------------------- 1 | break; -------------------------------------------------------------------------------- /tests/cases/compiler/breakTarget1.ts: -------------------------------------------------------------------------------- 1 | target: 2 | break target; -------------------------------------------------------------------------------- /tests/cases/compiler/continueNotInIterationStatement1.ts: -------------------------------------------------------------------------------- 1 | continue; -------------------------------------------------------------------------------- /tests/cases/compiler/doWhileLoop.ts: -------------------------------------------------------------------------------- 1 | do { } while (false); 2 | var n; -------------------------------------------------------------------------------- /tests/cases/compiler/functionOverloads3.ts: -------------------------------------------------------------------------------- 1 | function foo():string; -------------------------------------------------------------------------------- /tests/cases/compiler/indexWithoutParamType.ts: -------------------------------------------------------------------------------- 1 | var y: { []; } // Error -------------------------------------------------------------------------------- /tests/cases/compiler/invalidSplice.ts: -------------------------------------------------------------------------------- 1 | var arr = [].splice(0,3,4,5); -------------------------------------------------------------------------------- /tests/cases/compiler/invalidUnicodeEscapeSequance.ts: -------------------------------------------------------------------------------- 1 | var arg\u003 -------------------------------------------------------------------------------- /tests/cases/compiler/invalidUnicodeEscapeSequance2.ts: -------------------------------------------------------------------------------- 1 | var arg\uxxxx -------------------------------------------------------------------------------- /tests/cases/compiler/moduleNoEmit.ts: -------------------------------------------------------------------------------- 1 | module Foo { 2 | 1+1; 3 | } -------------------------------------------------------------------------------- /tests/cases/compiler/newMissingIdentifier.ts: -------------------------------------------------------------------------------- 1 | var x = new (); 2 | -------------------------------------------------------------------------------- /tests/cases/compiler/objectLiteral2.ts: -------------------------------------------------------------------------------- 1 | var v30 = {a:1, b:2}, v31; -------------------------------------------------------------------------------- /tests/cases/compiler/parse2.ts: -------------------------------------------------------------------------------- 1 | function foo() { 2 | foo( 3 | } -------------------------------------------------------------------------------- /tests/cases/compiler/primitiveTypeAsmoduleName.ts: -------------------------------------------------------------------------------- 1 | module string {} -------------------------------------------------------------------------------- /tests/cases/compiler/restParameterNotLast.ts: -------------------------------------------------------------------------------- 1 | function f(...x, y) { } -------------------------------------------------------------------------------- /tests/cases/compiler/topLevelLambda3.ts: -------------------------------------------------------------------------------- 1 | var f = () => {this.window;} -------------------------------------------------------------------------------- /tests/cases/compiler/unaryOperators1.ts: -------------------------------------------------------------------------------- 1 | +foo; 2 | -bar; 3 | ~quux; -------------------------------------------------------------------------------- /tests/cases/compiler/unterminatedRegexAtEndOfSource1.ts: -------------------------------------------------------------------------------- 1 | var a = / -------------------------------------------------------------------------------- /tests/cases/compiler/unterminatedStringLiteralWithBackslash1.ts: -------------------------------------------------------------------------------- 1 | "\ -------------------------------------------------------------------------------- /tests/cases/compiler/varArgWithNoParamName.ts: -------------------------------------------------------------------------------- 1 | function t1(...) {} -------------------------------------------------------------------------------- /tests/cases/projects/declareVariableCollision/in1.d.ts: -------------------------------------------------------------------------------- 1 | import a = A; -------------------------------------------------------------------------------- /tests/cases/projects/declareVariableCollision/in2.d.ts: -------------------------------------------------------------------------------- 1 | import a = A; -------------------------------------------------------------------------------- /tests/cases/projects/moduleMergeOrder/b.ts: -------------------------------------------------------------------------------- 1 | module Test {} 2 | 3 | -------------------------------------------------------------------------------- /src/services/syntax/languageVersion.ts: -------------------------------------------------------------------------------- 1 | module TypeScript { 2 | 3 | } -------------------------------------------------------------------------------- /tests/cases/compiler/ClassDeclaration9.ts: -------------------------------------------------------------------------------- 1 | class C { 2 | foo(); 3 | } -------------------------------------------------------------------------------- /tests/cases/compiler/InterfaceDeclaration8.ts: -------------------------------------------------------------------------------- 1 | interface string { 2 | } -------------------------------------------------------------------------------- /tests/cases/compiler/binaryArithmatic3.ts: -------------------------------------------------------------------------------- 1 | var v = undefined | undefined; -------------------------------------------------------------------------------- /tests/cases/compiler/contextualTyping1.ts: -------------------------------------------------------------------------------- 1 | var foo: {id:number;} = {id:4}; -------------------------------------------------------------------------------- /tests/cases/compiler/continueTarget1.ts: -------------------------------------------------------------------------------- 1 | target: 2 | continue target; -------------------------------------------------------------------------------- /tests/cases/compiler/convertKeywords.ts: -------------------------------------------------------------------------------- 1 | var abstract; 2 | 3 | 4 | -------------------------------------------------------------------------------- /tests/cases/compiler/duplicateVariableDeclaration1.ts: -------------------------------------------------------------------------------- 1 | var v 2 | var v -------------------------------------------------------------------------------- /tests/cases/compiler/primitiveTypeAsInterfaceName.ts: -------------------------------------------------------------------------------- 1 | interface number {} -------------------------------------------------------------------------------- /tests/cases/compiler/propertyAccess2.ts: -------------------------------------------------------------------------------- 1 | var foo: number; 2 | foo.toBAZ(); -------------------------------------------------------------------------------- /tests/cases/compiler/propertyAccess6.ts: -------------------------------------------------------------------------------- 1 | var foo: any; 2 | foo.bar = 4; -------------------------------------------------------------------------------- /tests/cases/compiler/restArgMissingName.ts: -------------------------------------------------------------------------------- 1 | function sum (...) {} 2 | -------------------------------------------------------------------------------- /tests/cases/compiler/slashBeforeVariableDeclaration1.ts: -------------------------------------------------------------------------------- 1 | \ declare var v; -------------------------------------------------------------------------------- /tests/cases/compiler/unicodeIdentifierName2.ts: -------------------------------------------------------------------------------- 1 | var a₁ = "hello"; alert(a₁) -------------------------------------------------------------------------------- /tests/cases/compiler/voidConstructor.ts: -------------------------------------------------------------------------------- 1 | var foo:{ new ( ): void; } 2 | -------------------------------------------------------------------------------- /tests/cases/conformance/scanner/ecmascript3/scannerES3NumericLiteral1.ts: -------------------------------------------------------------------------------- 1 | 0 -------------------------------------------------------------------------------- /tests/cases/projects/NestedLocalModule-SimpleCase/test2.ts: -------------------------------------------------------------------------------- 1 | export var $; -------------------------------------------------------------------------------- /tests/cases/compiler/ParameterList5.ts: -------------------------------------------------------------------------------- 1 | function A(): (public B) => C { 2 | } -------------------------------------------------------------------------------- /tests/cases/compiler/asiAmbientFunctionDeclaration.ts: -------------------------------------------------------------------------------- 1 | declare function foo() -------------------------------------------------------------------------------- /tests/cases/compiler/breakTarget6.ts: -------------------------------------------------------------------------------- 1 | while (true) { 2 | break target; 3 | } -------------------------------------------------------------------------------- /tests/cases/compiler/callOnClass.ts: -------------------------------------------------------------------------------- 1 | class C { } 2 | var c = C(); 3 | 4 | -------------------------------------------------------------------------------- /tests/cases/compiler/class2.ts: -------------------------------------------------------------------------------- 1 | class foo { constructor() { static f = 3; } } -------------------------------------------------------------------------------- /tests/cases/compiler/contextualTyping34.ts: -------------------------------------------------------------------------------- 1 | var foo = <{ id: number;}> ({id:4}); -------------------------------------------------------------------------------- /tests/cases/compiler/duplicateTypeParameters1.ts: -------------------------------------------------------------------------------- 1 | function A() { } 2 | -------------------------------------------------------------------------------- /tests/cases/compiler/emptyGenericParamList.ts: -------------------------------------------------------------------------------- 1 | class I {} 2 | var x: I<>; -------------------------------------------------------------------------------- /tests/cases/compiler/genericInference1.ts: -------------------------------------------------------------------------------- 1 | ['a', 'b', 'c'].map(x => x.length); -------------------------------------------------------------------------------- /tests/cases/compiler/isLiteral2.ts: -------------------------------------------------------------------------------- 1 | // @target: es3 2 | var x: number = 02343 -------------------------------------------------------------------------------- /tests/cases/compiler/numericMethodName1.ts: -------------------------------------------------------------------------------- 1 | class C { 2 | 1 = 2; 3 | } 4 | -------------------------------------------------------------------------------- /tests/cases/compiler/propertyAccess3.ts: -------------------------------------------------------------------------------- 1 | var foo: boolean; 2 | foo.toBAZ(); -------------------------------------------------------------------------------- /tests/cases/compiler/randomSemicolons1.ts: -------------------------------------------------------------------------------- 1 | ; ; 2 | var a = 1; 3 | ; 4 | -------------------------------------------------------------------------------- /tests/cases/compiler/thisKeyword.ts: -------------------------------------------------------------------------------- 1 | module foo { 2 | this.bar = 4; 3 | } -------------------------------------------------------------------------------- /tests/cases/compiler/undefinedTypeArgument1.ts: -------------------------------------------------------------------------------- 1 | var cats = new Array(); -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/Fuzz/parser768531.ts: -------------------------------------------------------------------------------- 1 | {a: 3} 2 | /x/ -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/TupleTypes/TupleType3.ts: -------------------------------------------------------------------------------- 1 | var v: [] -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/TupleTypes/TupleType4.ts: -------------------------------------------------------------------------------- 1 | var v: [ -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/parserDebuggerStatement1.ts: -------------------------------------------------------------------------------- 1 | debugger -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/parserUnicode3.ts: -------------------------------------------------------------------------------- 1 | class 剩下 { 2 | } -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/parserVoidExpression1.ts: -------------------------------------------------------------------------------- 1 | void 0; -------------------------------------------------------------------------------- /tests/cases/conformance/scanner/ecmascript3/scannerES3NumericLiteral2.ts: -------------------------------------------------------------------------------- 1 | 01 -------------------------------------------------------------------------------- /tests/cases/conformance/scanner/ecmascript3/scannerES3NumericLiteral3.ts: -------------------------------------------------------------------------------- 1 | 01.0 -------------------------------------------------------------------------------- /tests/cases/conformance/scanner/ecmascript3/scannerES3NumericLiteral4.ts: -------------------------------------------------------------------------------- 1 | 1e -------------------------------------------------------------------------------- /tests/cases/conformance/scanner/ecmascript3/scannerES3NumericLiteral5.ts: -------------------------------------------------------------------------------- 1 | 1e0 -------------------------------------------------------------------------------- /tests/cases/conformance/scanner/ecmascript3/scannerES3NumericLiteral6.ts: -------------------------------------------------------------------------------- 1 | 1e+ -------------------------------------------------------------------------------- /tests/cases/conformance/scanner/ecmascript3/scannerES3NumericLiteral7.ts: -------------------------------------------------------------------------------- 1 | 1e+0 -------------------------------------------------------------------------------- /tests/cases/unittests/services/formatting/testCode/formatting/emptyBlock.ts: -------------------------------------------------------------------------------- 1 | {} -------------------------------------------------------------------------------- /tests/baselines/reference/project/declarationsCascadingImports/amd/useModule.js: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /tests/baselines/reference/project/declarationsCascadingImports/node/useModule.js: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /tests/baselines/reference/project/outModuleSimpleSpecifyOutputFile/amd/bin/test.js: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /tests/baselines/reference/project/outModuleSimpleSpecifyOutputFile/node/bin/test.js: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /tests/baselines/reference/project/visibilityOfTypeUsedAcrossModules/node/server.js: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /tests/cases/compiler/ArrowFunctionExpression1.ts: -------------------------------------------------------------------------------- 1 | var v = (public x: string) => { }; -------------------------------------------------------------------------------- /tests/cases/compiler/ClassDeclaration8.ts: -------------------------------------------------------------------------------- 1 | class C { 2 | constructor(); 3 | } -------------------------------------------------------------------------------- /tests/cases/compiler/FunctionDeclaration4.ts: -------------------------------------------------------------------------------- 1 | function foo(); 2 | function bar() { } -------------------------------------------------------------------------------- /tests/cases/compiler/assignmentToParenthesizedExpression1.ts: -------------------------------------------------------------------------------- 1 | var x; 2 | (1, x)=0; -------------------------------------------------------------------------------- /tests/cases/compiler/augmentArray.ts: -------------------------------------------------------------------------------- 1 | interface Array { 2 | (): any[]; 3 | } -------------------------------------------------------------------------------- /tests/cases/compiler/class1.ts: -------------------------------------------------------------------------------- 1 | interface foo{ } // error 2 | class foo{ } // error -------------------------------------------------------------------------------- /tests/cases/compiler/commentsAtEndOfFile1.ts: -------------------------------------------------------------------------------- 1 | Input: 2 | ; 3 | //Testing two 4 | -------------------------------------------------------------------------------- /tests/cases/compiler/constraintErrors1.ts: -------------------------------------------------------------------------------- 1 | function foo5(test: T) { } -------------------------------------------------------------------------------- /tests/cases/compiler/contextualTyping28.ts: -------------------------------------------------------------------------------- 1 | function foo(param:number[]){}; foo([1]); -------------------------------------------------------------------------------- /tests/cases/compiler/contextualTyping31.ts: -------------------------------------------------------------------------------- 1 | function foo(param:number[]){}; foo([1]); -------------------------------------------------------------------------------- /tests/cases/compiler/contextualTyping6.ts: -------------------------------------------------------------------------------- 1 | var foo:{id:number;}[] = [{id:1}, {id:2}]; -------------------------------------------------------------------------------- /tests/cases/compiler/debuggerEmit.ts: -------------------------------------------------------------------------------- 1 | var x = function () { debugger; } 2 | x(); -------------------------------------------------------------------------------- /tests/cases/compiler/deprecatedBool.ts: -------------------------------------------------------------------------------- 1 | var b4: boolean; 2 | var bool: boolean; 3 | -------------------------------------------------------------------------------- /tests/cases/compiler/emptyTypeArgumentList.ts: -------------------------------------------------------------------------------- 1 | function foo() { } 2 | foo<>(); -------------------------------------------------------------------------------- /tests/cases/compiler/enumWithQuotedElementName1.ts: -------------------------------------------------------------------------------- 1 | enum E { 2 | 'fo"o', 3 | } -------------------------------------------------------------------------------- /tests/cases/compiler/enumWithQuotedElementName2.ts: -------------------------------------------------------------------------------- 1 | enum E { 2 | "fo'o", 3 | } -------------------------------------------------------------------------------- /tests/cases/compiler/incompleteObjectLiteral1.ts: -------------------------------------------------------------------------------- 1 | var tt = { aa; } 2 | var x = tt; -------------------------------------------------------------------------------- /tests/cases/compiler/indexWithoutParamType2.ts: -------------------------------------------------------------------------------- 1 | class C { 2 | [x]: string 3 | } -------------------------------------------------------------------------------- /tests/cases/compiler/multiExtendsSplitInterfaces1.ts: -------------------------------------------------------------------------------- 1 | self.cancelAnimationFrame(0); -------------------------------------------------------------------------------- /tests/cases/compiler/primitiveTypeAsInterfaceNameGeneric.ts: -------------------------------------------------------------------------------- 1 | interface number {} -------------------------------------------------------------------------------- /tests/cases/compiler/propertyAccess7.ts: -------------------------------------------------------------------------------- 1 | var foo: string; 2 | foo.toUpperCase(); -------------------------------------------------------------------------------- /tests/cases/compiler/quotedPropertyName1.ts: -------------------------------------------------------------------------------- 1 | class Test1 { 2 | "prop1" = 0; 3 | } -------------------------------------------------------------------------------- /tests/cases/compiler/strictMode4.ts: -------------------------------------------------------------------------------- 1 | "use strict"; 2 | 3 | class A { 4 | } 5 | -------------------------------------------------------------------------------- /tests/cases/compiler/stringHasStringValuedNumericIndexer.ts: -------------------------------------------------------------------------------- 1 | var str: string = ""[0]; -------------------------------------------------------------------------------- /tests/cases/compiler/switchCases.ts: -------------------------------------------------------------------------------- 1 | switch(0) { 2 | case 1: 3 | break; 4 | } 5 | -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/Expressions/parserUnaryExpression6.ts: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/Generics/parserAmbiguity2.ts: -------------------------------------------------------------------------------- 1 | f(g7); -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/MissingTokens/parserMissingToken2.ts: -------------------------------------------------------------------------------- 1 | / b; -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/SkippedTokens/parserSkippedTokens1.ts: -------------------------------------------------------------------------------- 1 | \ -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/SkippedTokens/parserSkippedTokens2.ts: -------------------------------------------------------------------------------- 1 | \\ -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/Statements/parserBlockStatement1.d.ts: -------------------------------------------------------------------------------- 1 | {} -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/Statements/parserEmptyStatement1.d.ts: -------------------------------------------------------------------------------- 1 | ; -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/TupleTypes/TupleType1.ts: -------------------------------------------------------------------------------- 1 | var v: [number] -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/TupleTypes/TupleType5.ts: -------------------------------------------------------------------------------- 1 | var v: [number,] -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/Types/parserTypeQuery1.ts: -------------------------------------------------------------------------------- 1 | var v: typeof A -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/parserDebuggerStatement2.ts: -------------------------------------------------------------------------------- 1 | debugger; -------------------------------------------------------------------------------- /tests/cases/conformance/types/primitives/null/directReferenceToNull.ts: -------------------------------------------------------------------------------- 1 | var x: Null; -------------------------------------------------------------------------------- /tests/cases/projects/non-relative/lib/bar/a.ts: -------------------------------------------------------------------------------- 1 | export function hello() { } 2 | -------------------------------------------------------------------------------- /tests/cases/projects/non-relative/lib/foo/b.ts: -------------------------------------------------------------------------------- 1 | export function hello() { } 2 | -------------------------------------------------------------------------------- /tests/baselines/reference/project/outModuleMultifolderSpecifyOutputFile/amd/bin/test.js: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /tests/baselines/reference/project/outModuleMultifolderSpecifyOutputFile/node/bin/test.js: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /tests/baselines/reference/project/outModuleSimpleSpecifyOutputFile/amd/bin/test.d.ts: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /tests/baselines/reference/project/outModuleSimpleSpecifyOutputFile/node/bin/test.d.ts: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /tests/baselines/reference/project/outModuleSubfolderSpecifyOutputFile/amd/bin/test.d.ts: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /tests/baselines/reference/project/outModuleSubfolderSpecifyOutputFile/amd/bin/test.js: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /tests/baselines/reference/project/outModuleSubfolderSpecifyOutputFile/node/bin/test.d.ts: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /tests/baselines/reference/project/outModuleSubfolderSpecifyOutputFile/node/bin/test.js: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /tests/baselines/reference/project/visibilityOfTypeUsedAcrossModules/node/commands.js: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /tests/cases/compiler/ExportAssignment7.ts: -------------------------------------------------------------------------------- 1 | export class C { 2 | } 3 | 4 | export = B; -------------------------------------------------------------------------------- /tests/cases/compiler/ExportAssignment8.ts: -------------------------------------------------------------------------------- 1 | export = B; 2 | 3 | export class C { 4 | } -------------------------------------------------------------------------------- /tests/cases/compiler/FunctionDeclaration7.ts: -------------------------------------------------------------------------------- 1 | module M { 2 | function foo(); 3 | } -------------------------------------------------------------------------------- /tests/cases/compiler/ParameterList13.ts: -------------------------------------------------------------------------------- 1 | interface I { 2 | new (public x); 3 | } -------------------------------------------------------------------------------- /tests/cases/compiler/anyPlusAny1.ts: -------------------------------------------------------------------------------- 1 | var x; 2 | x.name = "hello"; 3 | var z = x + x; -------------------------------------------------------------------------------- /tests/cases/compiler/arguments.ts: -------------------------------------------------------------------------------- 1 | function f() { 2 | var x=arguments[12]; 3 | } -------------------------------------------------------------------------------- /tests/cases/compiler/assignToModule.ts: -------------------------------------------------------------------------------- 1 | module A {} 2 | A = undefined; // invalid LHS -------------------------------------------------------------------------------- /tests/cases/compiler/cannotInvokeNewOnIndexExpression.ts: -------------------------------------------------------------------------------- 1 | var test: any[] = new any[1]; -------------------------------------------------------------------------------- /tests/cases/compiler/classImplementsClass1.ts: -------------------------------------------------------------------------------- 1 | class A { } 2 | class C implements A { } -------------------------------------------------------------------------------- /tests/cases/compiler/classInheritence.ts: -------------------------------------------------------------------------------- 1 | class B extends A { } 2 | class A extends A { } -------------------------------------------------------------------------------- /tests/cases/compiler/contextualTyping16.ts: -------------------------------------------------------------------------------- 1 | var foo: {id:number;} = {id:4}; foo = {id:5}; -------------------------------------------------------------------------------- /tests/cases/compiler/contextualTyping2.ts: -------------------------------------------------------------------------------- 1 | var foo: {id:number;} = {id:4, name:"foo"}; -------------------------------------------------------------------------------- /tests/cases/compiler/contextualTyping29.ts: -------------------------------------------------------------------------------- 1 | function foo(param:number[]){}; foo([1, 3]); -------------------------------------------------------------------------------- /tests/cases/compiler/contextualTyping3.ts: -------------------------------------------------------------------------------- 1 | class foo { public bar:{id:number;} = {id:5}; } -------------------------------------------------------------------------------- /tests/cases/compiler/contextualTyping30.ts: -------------------------------------------------------------------------------- 1 | function foo(param:number[]){}; foo([1, "a"]); -------------------------------------------------------------------------------- /tests/cases/compiler/contextualTyping35.ts: -------------------------------------------------------------------------------- 1 | var foo = <{ id: number;}> {id:4, name: "as"}; -------------------------------------------------------------------------------- /tests/cases/compiler/contextualTyping5.ts: -------------------------------------------------------------------------------- 1 | class foo { public bar:{id:number;} = { }; } -------------------------------------------------------------------------------- /tests/cases/compiler/contextualTyping7.ts: -------------------------------------------------------------------------------- 1 | var foo:{id:number;}[] = [<{id:number;}>({})]; -------------------------------------------------------------------------------- /tests/cases/compiler/contextualTyping8.ts: -------------------------------------------------------------------------------- 1 | var foo:{id:number;}[] = [<{id:number;}>({})]; -------------------------------------------------------------------------------- /tests/cases/compiler/continueInIterationStatement3.ts: -------------------------------------------------------------------------------- 1 | for (;;) { 2 | continue; 3 | } -------------------------------------------------------------------------------- /tests/cases/compiler/continueTarget6.ts: -------------------------------------------------------------------------------- 1 | while (true) { 2 | continue target; 3 | } -------------------------------------------------------------------------------- /tests/cases/compiler/duplicateLabel1.ts: -------------------------------------------------------------------------------- 1 | target: 2 | target: 3 | while (true) { 4 | } -------------------------------------------------------------------------------- /tests/cases/compiler/emptyTypeArgumentListWithNew.ts: -------------------------------------------------------------------------------- 1 | class foo { } 2 | new foo<>(); -------------------------------------------------------------------------------- /tests/cases/compiler/enumNegativeLiteral1.ts: -------------------------------------------------------------------------------- 1 | enum E { 2 | a = -5, b, c 3 | } 4 | -------------------------------------------------------------------------------- /tests/cases/compiler/enumWithParenthesizedInitializer1.ts: -------------------------------------------------------------------------------- 1 | enum E { 2 | e = -(3 3 | } -------------------------------------------------------------------------------- /tests/cases/compiler/enumWithUnicodeEscape1.ts: -------------------------------------------------------------------------------- 1 | enum E { 2 | 'gold \u2730' 3 | } 4 | -------------------------------------------------------------------------------- /tests/cases/compiler/es6ClassTest9.ts: -------------------------------------------------------------------------------- 1 | declare class foo(); 2 | function foo() {} 3 | -------------------------------------------------------------------------------- /tests/cases/compiler/exportAssignmentWithExportModifier.ts: -------------------------------------------------------------------------------- 1 | var x; 2 | export export = x; -------------------------------------------------------------------------------- /tests/cases/compiler/forInStatement1.ts: -------------------------------------------------------------------------------- 1 | var expr: any; 2 | for (var a in expr) { 3 | } -------------------------------------------------------------------------------- /tests/cases/compiler/functionCall1.ts: -------------------------------------------------------------------------------- 1 | function foo():any{return ""}; 2 | var x = foo(); -------------------------------------------------------------------------------- /tests/cases/compiler/quotedFunctionName1.ts: -------------------------------------------------------------------------------- 1 | class Test1 { 2 | "prop1"() { } 3 | } -------------------------------------------------------------------------------- /tests/cases/compiler/redefineArray.ts: -------------------------------------------------------------------------------- 1 | Array = function (n:number, s:string) {return n;}; -------------------------------------------------------------------------------- /tests/cases/compiler/separate1-2.ts: -------------------------------------------------------------------------------- 1 | module X { 2 | export function f() { } 3 | } -------------------------------------------------------------------------------- /tests/cases/compiler/sourceMap-EmptyFile1.ts: -------------------------------------------------------------------------------- 1 | // @target: ES3 2 | // @sourcemap: true -------------------------------------------------------------------------------- /tests/cases/compiler/sourceMapValidationDebugger.ts: -------------------------------------------------------------------------------- 1 | // @sourcemap: true 2 | debugger; -------------------------------------------------------------------------------- /tests/cases/compiler/varAndFunctionShareName.ts: -------------------------------------------------------------------------------- 1 | var myFn; 2 | function myFn(): any { } -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/Expressions/parserUnaryExpression1.ts: -------------------------------------------------------------------------------- 1 | ++this; -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/Expressions/parserUnaryExpression3.ts: -------------------------------------------------------------------------------- 1 | ++[0]; -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/Expressions/parserUnaryExpression4.ts: -------------------------------------------------------------------------------- 1 | ++{}; -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/Generics/parserAmbiguity1.ts: -------------------------------------------------------------------------------- 1 | f(g(7)); -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/ObjectTypes/parserObjectType1.ts: -------------------------------------------------------------------------------- 1 | var v: {}; -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/SkippedTokens/parserSkippedTokens12.ts: -------------------------------------------------------------------------------- 1 | \ \ \ -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/SkippedTokens/parserSkippedTokens18.ts: -------------------------------------------------------------------------------- 1 | foo(a \ -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/SkippedTokens/parserSkippedTokens3.ts: -------------------------------------------------------------------------------- 1 | \ ; \ -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/Statements/parserBreakStatement1.d.ts: -------------------------------------------------------------------------------- 1 | break; -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/Statements/parserReturnStatement1.d.ts: -------------------------------------------------------------------------------- 1 | return; -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/Statements/parserThrowStatement1.d.ts: -------------------------------------------------------------------------------- 1 | throw e; -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/Types/parserTypeQuery2.ts: -------------------------------------------------------------------------------- 1 | var v: typeof A; -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/Types/parserTypeQuery3.ts: -------------------------------------------------------------------------------- 1 | var v: typeof A. -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/Types/parserTypeQuery4.ts: -------------------------------------------------------------------------------- 1 | var v: typeof A.; -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/Types/parserTypeQuery5.ts: -------------------------------------------------------------------------------- 1 | var v: typeof A.B -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/Types/parserTypeQuery6.ts: -------------------------------------------------------------------------------- 1 | var v: typeof A.B; -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/Types/parserTypeQuery7.ts: -------------------------------------------------------------------------------- 1 | var v: typeof A[] -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/Types/parserTypeQuery8.ts: -------------------------------------------------------------------------------- 1 | var v: typeof A -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/parservoidInQualifiedName0.ts: -------------------------------------------------------------------------------- 1 | var v : void; -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/parservoidInQualifiedName1.ts: -------------------------------------------------------------------------------- 1 | var v : void.x; -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/parservoidInQualifiedName2.ts: -------------------------------------------------------------------------------- 1 | var v : x.void; -------------------------------------------------------------------------------- /tests/cases/conformance/scanner/ecmascript5/scannerUnexpectedNullCharacter1.ts: -------------------------------------------------------------------------------- 1 | foo+bar; -------------------------------------------------------------------------------- /tests/cases/projects/RelativePaths/app.ts: -------------------------------------------------------------------------------- 1 | import a = require('A/a'); 2 | 3 | a.A(); -------------------------------------------------------------------------------- /tests/cases/unittests/services/formatting/testCode/formatting/emptyBlockBaseline.ts: -------------------------------------------------------------------------------- 1 | { } -------------------------------------------------------------------------------- /tests/cases/unittests/services/formatting/testCode/testCode/formatting/emptyBlock.ts: -------------------------------------------------------------------------------- 1 | {} -------------------------------------------------------------------------------- /tests/baselines/reference/bind2.js: -------------------------------------------------------------------------------- 1 | //// [bind2.ts] 2 | 3 | 4 | //// [bind2.js] 5 | -------------------------------------------------------------------------------- /tests/baselines/reference/project/baseline2/node/dont_emit.js: -------------------------------------------------------------------------------- 1 | var p = { x: 10, y: 20 }; 2 | -------------------------------------------------------------------------------- /tests/baselines/reference/project/maprootUrlModuleSimpleSpecifyOutputFile/amd/bin/test.d.ts: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /tests/baselines/reference/project/maprootUrlModuleSimpleSpecifyOutputFile/node/bin/test.d.ts: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /tests/baselines/reference/project/outModuleMultifolderSpecifyOutputFile/amd/bin/test.d.ts: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /tests/baselines/reference/project/outModuleMultifolderSpecifyOutputFile/node/bin/test.d.ts: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /tests/baselines/reference/project/sourcemapModuleSimpleSpecifyOutputFile/amd/bin/test.d.ts: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /tests/baselines/reference/project/sourcemapModuleSimpleSpecifyOutputFile/node/bin/test.d.ts: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /tests/baselines/reference/project/sourcemapModuleSubfolderSpecifyOutputFile/amd/bin/test.d.ts: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /tests/cases/compiler/ClassDeclaration13.ts: -------------------------------------------------------------------------------- 1 | class C { 2 | foo(); 3 | bar() { } 4 | } -------------------------------------------------------------------------------- /tests/cases/compiler/ClassDeclaration21.ts: -------------------------------------------------------------------------------- 1 | class C { 2 | 0(); 3 | 1() { } 4 | } -------------------------------------------------------------------------------- /tests/cases/compiler/ambientEnumElementInitializer1.ts: -------------------------------------------------------------------------------- 1 | declare enum E { 2 | e = 3 3 | } -------------------------------------------------------------------------------- /tests/cases/compiler/ambientEnumElementInitializer4.ts: -------------------------------------------------------------------------------- 1 | declare enum E { 2 | e = 0xA 3 | } -------------------------------------------------------------------------------- /tests/cases/compiler/ambientEnumElementInitializer5.ts: -------------------------------------------------------------------------------- 1 | declare enum E { 2 | e = -0xA 3 | } -------------------------------------------------------------------------------- /tests/cases/compiler/breakInIterationOrSwitchStatement1.ts: -------------------------------------------------------------------------------- 1 | while (true) { 2 | break; 3 | } -------------------------------------------------------------------------------- /tests/cases/compiler/breakInIterationOrSwitchStatement3.ts: -------------------------------------------------------------------------------- 1 | for (;;) { 2 | break; 3 | } -------------------------------------------------------------------------------- /tests/cases/compiler/breakTarget2.ts: -------------------------------------------------------------------------------- 1 | target: 2 | while (true) { 3 | break target; 4 | } -------------------------------------------------------------------------------- /tests/cases/compiler/castNewObjectBug.ts: -------------------------------------------------------------------------------- 1 | interface Foo { } 2 | var xx = new Object(); -------------------------------------------------------------------------------- /tests/cases/compiler/catchClauseWithTypeAnnotation.ts: -------------------------------------------------------------------------------- 1 | try { 2 | } catch (e: any) { 3 | } -------------------------------------------------------------------------------- /tests/cases/compiler/classMethodWithKeywordName1.ts: -------------------------------------------------------------------------------- 1 | class C { 2 | static try() {} 3 | } -------------------------------------------------------------------------------- /tests/cases/compiler/classOverloadForFunction.ts: -------------------------------------------------------------------------------- 1 | class foo { }; 2 | function foo() {} 3 | -------------------------------------------------------------------------------- /tests/cases/compiler/classOverloadForFunction2.ts: -------------------------------------------------------------------------------- 1 | function bar(): string; 2 | class bar {} -------------------------------------------------------------------------------- /tests/cases/compiler/contextualTyping13.ts: -------------------------------------------------------------------------------- 1 | var foo:(a:number)=>number = function(a){return a}; -------------------------------------------------------------------------------- /tests/cases/compiler/contextualTyping37.ts: -------------------------------------------------------------------------------- 1 | var foo = <{ id: number; }[]>[{ foo: "s" }, { }]; -------------------------------------------------------------------------------- /tests/cases/compiler/continueInIterationStatement1.ts: -------------------------------------------------------------------------------- 1 | while (true) { 2 | continue; 3 | } -------------------------------------------------------------------------------- /tests/cases/compiler/deleteOperatorInStrictMode.ts: -------------------------------------------------------------------------------- 1 | "use strict" 2 | var a; 3 | delete a; -------------------------------------------------------------------------------- /tests/cases/compiler/enumGenericTypeClash.ts: -------------------------------------------------------------------------------- 1 | class X { } 2 | enum X { MyVal } 3 | -------------------------------------------------------------------------------- /tests/cases/compiler/exportAssignmentWithDeclareModifier.ts: -------------------------------------------------------------------------------- 1 | var x; 2 | declare export = x; -------------------------------------------------------------------------------- /tests/cases/compiler/forInStatement2.ts: -------------------------------------------------------------------------------- 1 | var expr: number; 2 | for (var a in expr) { 3 | } -------------------------------------------------------------------------------- /tests/cases/compiler/functionCall15.ts: -------------------------------------------------------------------------------- 1 | function foo(a?:string, b?:number, ...b:number[]){} -------------------------------------------------------------------------------- /tests/cases/compiler/functionCall2.ts: -------------------------------------------------------------------------------- 1 | function foo():number{return 1}; 2 | var x = foo(); -------------------------------------------------------------------------------- /tests/cases/compiler/functionCall3.ts: -------------------------------------------------------------------------------- 1 | function foo():any[]{return [1];} 2 | var x = foo(); -------------------------------------------------------------------------------- /tests/cases/compiler/globalThis.ts: -------------------------------------------------------------------------------- 1 | var __e = Math.E; // should not generate 'this.Math.E' -------------------------------------------------------------------------------- /tests/cases/compiler/indirectSelfReference.ts: -------------------------------------------------------------------------------- 1 | class a extends b{ } 2 | class b extends a{ } -------------------------------------------------------------------------------- /tests/cases/compiler/libdtsFix.ts: -------------------------------------------------------------------------------- 1 | interface HTMLElement { 2 | type: string; 3 | } 4 | -------------------------------------------------------------------------------- /tests/cases/compiler/moduleRedifinitionErrors.ts: -------------------------------------------------------------------------------- 1 | class A { 2 | } 3 | module A { 4 | } 5 | -------------------------------------------------------------------------------- /tests/cases/compiler/parse1.ts: -------------------------------------------------------------------------------- 1 | var bar = 42; 2 | function foo() { 3 | bar. 4 | } 5 | -------------------------------------------------------------------------------- /tests/cases/compiler/quotedFunctionName2.ts: -------------------------------------------------------------------------------- 1 | class Test1 { 2 | static "prop1"() { } 3 | } -------------------------------------------------------------------------------- /tests/cases/compiler/quotedPropertyName2.ts: -------------------------------------------------------------------------------- 1 | class Test1 { 2 | static "prop1" = 0; 3 | } -------------------------------------------------------------------------------- /tests/cases/compiler/sourceMap-SingleSpace1.ts: -------------------------------------------------------------------------------- 1 | // @target: ES3 2 | // @sourcemap: true 3 | -------------------------------------------------------------------------------- /tests/cases/compiler/staticIndexer.ts: -------------------------------------------------------------------------------- 1 | class C { 2 | static [s: string]: number; 3 | } -------------------------------------------------------------------------------- /tests/cases/compiler/strictMode1.ts: -------------------------------------------------------------------------------- 1 | "use strict"; 2 | class A {} 3 | class B extends A {} -------------------------------------------------------------------------------- /tests/cases/compiler/topLevelLambda4.ts: -------------------------------------------------------------------------------- 1 | //@module: amd 2 | export var x = () => this.window; -------------------------------------------------------------------------------- /tests/cases/compiler/undeclaredBase.ts: -------------------------------------------------------------------------------- 1 | module M { export class C extends M.I { } } 2 | 3 | -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/Expressions/parserUnaryExpression7.ts: -------------------------------------------------------------------------------- 1 | ++ new Foo(); -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/Generics/parserAmbiguity3.ts: -------------------------------------------------------------------------------- 1 | f(g < A, B > +(7)); -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/Generics/parserConstructorAmbiguity1.ts: -------------------------------------------------------------------------------- 1 | new Date -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/Generics/parserGenericClass1.ts: -------------------------------------------------------------------------------- 1 | class C { 2 | } -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/MissingTokens/parserMissingToken1.ts: -------------------------------------------------------------------------------- 1 | a / finally -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/Protected/Protected1.ts: -------------------------------------------------------------------------------- 1 | protected class C { 2 | } -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/Protected/Protected2.ts: -------------------------------------------------------------------------------- 1 | protected module M { 2 | } -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/RegressionTests/parser512084.ts: -------------------------------------------------------------------------------- 1 | class foo { 2 | -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/RegressionTests/parser521128.ts: -------------------------------------------------------------------------------- 1 | module.module { } -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/RegressionTests/parser566700.ts: -------------------------------------------------------------------------------- 1 | var v = ()({}); -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/RegressionTests/parser579071.ts: -------------------------------------------------------------------------------- 1 | var x = /fo(o/; -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/RegressionTests/parser645086_1.ts: -------------------------------------------------------------------------------- 1 | var v = /[]/]/ -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/RegressionTests/parser645086_2.ts: -------------------------------------------------------------------------------- 1 | var v = /[^]/]/ -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/RegressionTests/parser645086_3.ts: -------------------------------------------------------------------------------- 1 | var v = /[\]/]/ -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/RegressionTests/parser645086_4.ts: -------------------------------------------------------------------------------- 1 | var v = /[^\]/]/ -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/SkippedTokens/parserSkippedTokens11.ts: -------------------------------------------------------------------------------- 1 | ; \ \ \ -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/SkippedTokens/parserSkippedTokens13.ts: -------------------------------------------------------------------------------- 1 | /regexp/ \ ; -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/SkippedTokens/parserSkippedTokens17.ts: -------------------------------------------------------------------------------- 1 | foo(a, \ -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/SkippedTokens/parserSkippedTokens20.ts: -------------------------------------------------------------------------------- 1 | var v: X 0; 3 | } -------------------------------------------------------------------------------- /tests/cases/compiler/classAndInterface1.ts: -------------------------------------------------------------------------------- 1 | class cli { } // error 2 | interface cli { } // error -------------------------------------------------------------------------------- /tests/cases/compiler/contextualTyping11.ts: -------------------------------------------------------------------------------- 1 | class foo { public bar:{id:number;}[] = [({})]; } -------------------------------------------------------------------------------- /tests/cases/compiler/contextualTyping21.ts: -------------------------------------------------------------------------------- 1 | var foo:{id:number;}[] = [{id:1}]; foo = [{id:1}, 1]; -------------------------------------------------------------------------------- /tests/cases/compiler/contextualTyping38.ts: -------------------------------------------------------------------------------- 1 | var foo = <{ (): number; }> function(a) { return a }; -------------------------------------------------------------------------------- /tests/cases/compiler/contextualTyping9.ts: -------------------------------------------------------------------------------- 1 | var foo:{id:number;}[] = [{id:1}, {id:2, name:"foo"}]; -------------------------------------------------------------------------------- /tests/cases/compiler/continueTarget2.ts: -------------------------------------------------------------------------------- 1 | target: 2 | while (true) { 3 | continue target; 4 | } -------------------------------------------------------------------------------- /tests/cases/compiler/forInStatement4.ts: -------------------------------------------------------------------------------- 1 | var expr: any; 2 | for (var a: number in expr) { 3 | } -------------------------------------------------------------------------------- /tests/cases/compiler/instantiateTypeParameter.ts: -------------------------------------------------------------------------------- 1 | interface Foo { 2 | var x: T<>; 3 | } -------------------------------------------------------------------------------- /tests/cases/compiler/memberAccessOnConstructorType.ts: -------------------------------------------------------------------------------- 1 | var f: new () => void; 2 | f.arguments == 0; -------------------------------------------------------------------------------- /tests/cases/compiler/propertyAccess1.ts: -------------------------------------------------------------------------------- 1 | var foo: { a: number; }; 2 | foo.a = 4; 3 | foo.b = 5; -------------------------------------------------------------------------------- /tests/cases/compiler/quotedAccessorName1.ts: -------------------------------------------------------------------------------- 1 | class C { 2 | get "foo"() { return 0; } 3 | } -------------------------------------------------------------------------------- /tests/cases/compiler/recursiveBaseCheck4.ts: -------------------------------------------------------------------------------- 1 | class M extends M { } 2 | (new M).blah; -------------------------------------------------------------------------------- /tests/cases/compiler/restParamAsOptional.ts: -------------------------------------------------------------------------------- 1 | function f(...x?) { } 2 | function f2(...x = []) { } -------------------------------------------------------------------------------- /tests/cases/compiler/sourceMap-Comment1.ts: -------------------------------------------------------------------------------- 1 | // @target: ES3 2 | // @sourcemap: true 3 | // Comment -------------------------------------------------------------------------------- /tests/cases/compiler/sourceMap-NewLine1.ts: -------------------------------------------------------------------------------- 1 | // @target: ES3 2 | // @sourcemap: true 3 | 4 | -------------------------------------------------------------------------------- /tests/cases/compiler/sourceMap-SemiColon1.ts: -------------------------------------------------------------------------------- 1 | // @target: ES3 2 | // @sourcemap: true 3 | ; 4 | -------------------------------------------------------------------------------- /tests/cases/compiler/sourceMapValidationLabeled.ts: -------------------------------------------------------------------------------- 1 | // @sourcemap: true 2 | x: 3 | var b = 10; -------------------------------------------------------------------------------- /tests/cases/compiler/thisInModule.ts: -------------------------------------------------------------------------------- 1 | module myMod { 2 | var x; 3 | this.x = 5; 4 | } -------------------------------------------------------------------------------- /tests/cases/compiler/topLevelLambda.ts: -------------------------------------------------------------------------------- 1 | module M { 2 | var f = () => {this.window;} 3 | } 4 | -------------------------------------------------------------------------------- /tests/cases/compiler/topLevelLambda2.ts: -------------------------------------------------------------------------------- 1 | function foo(x:any) {} 2 | 3 | foo(()=>this.window); -------------------------------------------------------------------------------- /tests/cases/compiler/unresolvedTypeAssertionSymbol.ts: -------------------------------------------------------------------------------- 1 | var x = 1; 2 | var y = x; 3 | 4 | -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/ErrorRecovery/parserPublicBreak1.ts: -------------------------------------------------------------------------------- 1 | public break; 2 | -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/ExportAssignments/parserExportAssignment3.ts: -------------------------------------------------------------------------------- 1 | export = -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/ExportAssignments/parserExportAssignment4.ts: -------------------------------------------------------------------------------- 1 | export = ; -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/Expressions/parserObjectCreation2.ts: -------------------------------------------------------------------------------- 1 | new new Foo()() -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/Expressions/parserPostfixPostfixExpression1.ts: -------------------------------------------------------------------------------- 1 | a++ ++; -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/Expressions/parserPostfixUnaryExpression1.ts: -------------------------------------------------------------------------------- 1 | foo ++ ++; -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/Expressions/parserUnaryExpression2.ts: -------------------------------------------------------------------------------- 1 | ++function(e) { } -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/Expressions/parserUnaryExpression5.ts: -------------------------------------------------------------------------------- 1 | ++ delete foo.bar -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/Generics/parserGenericClass2.ts: -------------------------------------------------------------------------------- 1 | class C { 2 | } -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/Generics/parserGreaterThanTokenAmbiguity1.ts: -------------------------------------------------------------------------------- 1 | 1 >> 2; -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/Generics/parserGreaterThanTokenAmbiguity11.ts: -------------------------------------------------------------------------------- 1 | 1 >>= 2; -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/Generics/parserGreaterThanTokenAmbiguity12.ts: -------------------------------------------------------------------------------- 1 | 1 >> = 2; -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/Generics/parserGreaterThanTokenAmbiguity16.ts: -------------------------------------------------------------------------------- 1 | 1 >>>= 2; -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/Generics/parserGreaterThanTokenAmbiguity17.ts: -------------------------------------------------------------------------------- 1 | 1 >>> = 2; -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/Generics/parserGreaterThanTokenAmbiguity2.ts: -------------------------------------------------------------------------------- 1 | 1 > > 2; -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/Generics/parserGreaterThanTokenAmbiguity3.ts: -------------------------------------------------------------------------------- 1 | 1 >/**/> 2; -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/Generics/parserGreaterThanTokenAmbiguity6.ts: -------------------------------------------------------------------------------- 1 | 1 >>> 2; -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/Generics/parserGreaterThanTokenAmbiguity7.ts: -------------------------------------------------------------------------------- 1 | 1 >> > 2; -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/ObjectTypes/parserObjectType2.ts: -------------------------------------------------------------------------------- 1 | var v: { x: number }; -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/RegressionTests/parser509677.ts: -------------------------------------------------------------------------------- 1 | var n: { y: string }; -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/RegressionTests/parser596700.ts: -------------------------------------------------------------------------------- 1 | var regex2 = /[a-z/]$/i; -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/SkippedTokens/parserSkippedTokens19.ts: -------------------------------------------------------------------------------- 1 | \ declare var v; -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/SkippedTokens/parserSkippedTokens7.ts: -------------------------------------------------------------------------------- 1 | /*foo*/ \ /*bar*/ -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/Statements/parserDoStatement2.ts: -------------------------------------------------------------------------------- 1 | do{;}while(false)false -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/Statements/parserForStatement1.d.ts: -------------------------------------------------------------------------------- 1 | for (;;) { 2 | } -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/Statements/parserForStatement5.ts: -------------------------------------------------------------------------------- 1 | for ({} in b) { 2 | } -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/Statements/parserIfStatement1.d.ts: -------------------------------------------------------------------------------- 1 | if (foo) { 2 | } -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/Statements/parserWhileStatement1.d.ts: -------------------------------------------------------------------------------- 1 | while (e) { 2 | } -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/Statements/parserWithStatement1.d.ts: -------------------------------------------------------------------------------- 1 | with (foo) { 2 | } -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/VariableDeclarations/parserVariableDeclaration6.ts: -------------------------------------------------------------------------------- 1 | var -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/VariableDeclarations/parserVariableDeclaration8.ts: -------------------------------------------------------------------------------- 1 | var ; -------------------------------------------------------------------------------- /tests/cases/conformance/scanner/ecmascript5/scannerAdditiveExpression1.ts: -------------------------------------------------------------------------------- 1 | m.index+1+m[0].length; -------------------------------------------------------------------------------- /tests/cases/conformance/scanner/ecmascript5/scannerNumericLiteral3.ts: -------------------------------------------------------------------------------- 1 | // @target: ES5 2 | 01.0 -------------------------------------------------------------------------------- /tests/cases/conformance/scanner/ecmascript5/scannerNumericLiteral7.ts: -------------------------------------------------------------------------------- 1 | // @target: ES5 2 | 1e+0 -------------------------------------------------------------------------------- /tests/cases/conformance/scanner/ecmascript5/scannerUnicodeEscapeInKeyword1.ts: -------------------------------------------------------------------------------- 1 | \u0076ar x = "hello"; -------------------------------------------------------------------------------- /tests/cases/projects/baseline/emit.ts: -------------------------------------------------------------------------------- 1 | import g = require("./decl"); 2 | var p = g.point(10,20); -------------------------------------------------------------------------------- /tests/cases/unittests/services/formatting/testCode/formatting/onSemiColon.ts: -------------------------------------------------------------------------------- 1 | var a=b+c^d-e*++f; -------------------------------------------------------------------------------- /tests/cases/unittests/services/formatting/testCode/testCode/formatting/emptyBlockBaseline.ts: -------------------------------------------------------------------------------- 1 | { } -------------------------------------------------------------------------------- /tests/baselines/reference/emptyFile.js: -------------------------------------------------------------------------------- 1 | //// [emptyFile.ts] 2 | 3 | 4 | //// [emptyFile.js] 5 | -------------------------------------------------------------------------------- /tests/baselines/reference/project/mapRootAbsolutePathModuleSimpleSpecifyOutputFile/amd/bin/test.d.ts: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /tests/baselines/reference/project/mapRootAbsolutePathModuleSimpleSpecifyOutputFile/node/bin/test.d.ts: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /tests/baselines/reference/project/mapRootAbsolutePathModuleSubfolderSpecifyOutputFile/amd/bin/test.d.ts: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /tests/baselines/reference/project/mapRootRelativePathModuleSimpleSpecifyOutputFile/amd/bin/test.d.ts: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /tests/baselines/reference/project/mapRootRelativePathModuleSimpleSpecifyOutputFile/node/bin/test.d.ts: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /tests/baselines/reference/project/mapRootRelativePathModuleSubfolderSpecifyOutputFile/amd/bin/test.d.ts: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /tests/baselines/reference/project/sourceRootAbsolutePathModuleSimpleSpecifyOutputFile/amd/bin/test.d.ts: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /tests/baselines/reference/project/sourceRootRelativePathModuleSimpleSpecifyOutputFile/amd/bin/test.d.ts: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /tests/baselines/reference/project/sourcerootUrlModuleMultifolderSpecifyOutputFile/amd/bin/test.d.ts: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /tests/baselines/reference/project/sourcerootUrlModuleMultifolderSpecifyOutputFile/node/bin/test.d.ts: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /tests/cases/compiler/ClassDeclaration11.ts: -------------------------------------------------------------------------------- 1 | class C { 2 | constructor(); 3 | foo() { } 4 | } -------------------------------------------------------------------------------- /tests/cases/compiler/ClassDeclaration15.ts: -------------------------------------------------------------------------------- 1 | class C { 2 | foo(); 3 | constructor() { } 4 | } -------------------------------------------------------------------------------- /tests/cases/compiler/ambientEnumElementInitializer2.ts: -------------------------------------------------------------------------------- 1 | declare enum E { 2 | e = -3 // Negative 3 | } -------------------------------------------------------------------------------- /tests/cases/compiler/ambientEnumElementInitializer3.ts: -------------------------------------------------------------------------------- 1 | declare enum E { 2 | e = 3.3 // Decimal 3 | } -------------------------------------------------------------------------------- /tests/cases/compiler/arrayReferenceWithoutTypeArgs.ts: -------------------------------------------------------------------------------- 1 | class X { 2 | public f(a: Array) { } 3 | } -------------------------------------------------------------------------------- /tests/cases/compiler/breakInIterationOrSwitchStatement2.ts: -------------------------------------------------------------------------------- 1 | do { 2 | break; 3 | } 4 | while (true); -------------------------------------------------------------------------------- /tests/cases/compiler/collisionThisExpressionAndVarInGlobal.ts: -------------------------------------------------------------------------------- 1 | var _this = 1; 2 | var f = () => this; -------------------------------------------------------------------------------- /tests/cases/compiler/commentOnExpressionStatement1.ts: -------------------------------------------------------------------------------- 1 | // @comments: true 2 | 3 | 1 + 1; // Comment. -------------------------------------------------------------------------------- /tests/cases/compiler/conditionalExpression1.ts: -------------------------------------------------------------------------------- 1 | var x: boolean = (true ? 1 : ""); // should be an error -------------------------------------------------------------------------------- /tests/cases/compiler/contextualTyping10.ts: -------------------------------------------------------------------------------- 1 | class foo { public bar:{id:number;}[] = [{id:1}, {id:2}]; } -------------------------------------------------------------------------------- /tests/cases/compiler/contextualTyping17.ts: -------------------------------------------------------------------------------- 1 | var foo: {id:number;} = {id:4}; foo = {id: 5, name:"foo"}; -------------------------------------------------------------------------------- /tests/cases/compiler/contextualTyping18.ts: -------------------------------------------------------------------------------- 1 | var foo: {id:number;} = <{id:number;}>({ }); foo = {id: 5}; -------------------------------------------------------------------------------- /tests/cases/compiler/contextualTyping19.ts: -------------------------------------------------------------------------------- 1 | var foo:{id:number;}[] = [{id:1}]; foo = [{id:1}, {id:2}]; -------------------------------------------------------------------------------- /tests/cases/compiler/contextualTyping25.ts: -------------------------------------------------------------------------------- 1 | function foo(param:{id:number;}){}; foo(<{id:number;}>({})); -------------------------------------------------------------------------------- /tests/cases/compiler/contextualTyping26.ts: -------------------------------------------------------------------------------- 1 | function foo(param:{id:number;}){}; foo(<{id:number;}>({})); -------------------------------------------------------------------------------- /tests/cases/compiler/contextualTyping27.ts: -------------------------------------------------------------------------------- 1 | function foo(param:{id:number;}){}; foo(<{id:number;}>({})); -------------------------------------------------------------------------------- /tests/cases/compiler/contextualTyping39.ts: -------------------------------------------------------------------------------- 1 | var foo = <{ (): number; }> function() { return "err"; }; -------------------------------------------------------------------------------- /tests/cases/compiler/contextualTyping4.ts: -------------------------------------------------------------------------------- 1 | class foo { public bar:{id:number;} = {id:5, name:"foo"}; } -------------------------------------------------------------------------------- /tests/cases/compiler/continueInIterationStatement2.ts: -------------------------------------------------------------------------------- 1 | do { 2 | continue; 3 | } 4 | while (true); -------------------------------------------------------------------------------- /tests/cases/compiler/continueInIterationStatement4.ts: -------------------------------------------------------------------------------- 1 | for (var i in something) { 2 | continue; 3 | } -------------------------------------------------------------------------------- /tests/cases/compiler/debugger.ts: -------------------------------------------------------------------------------- 1 | debugger; 2 | 3 | function foo() { 4 | debugger; 5 | 6 | } -------------------------------------------------------------------------------- /tests/cases/compiler/enumWithPrimitiveName.ts: -------------------------------------------------------------------------------- 1 | enum string { } 2 | enum number { } 3 | enum any { } -------------------------------------------------------------------------------- /tests/cases/compiler/forInStatement5.ts: -------------------------------------------------------------------------------- 1 | var a: string; 2 | var expr: any; 3 | for (a in expr) { 4 | } -------------------------------------------------------------------------------- /tests/cases/compiler/forInStatement6.ts: -------------------------------------------------------------------------------- 1 | var a: any; 2 | var expr: any; 3 | for (a in expr) { 4 | } -------------------------------------------------------------------------------- /tests/cases/compiler/forInStatement7.ts: -------------------------------------------------------------------------------- 1 | var a: number; 2 | var expr: any; 3 | for (a in expr) { 4 | } -------------------------------------------------------------------------------- /tests/cases/compiler/genericArrayAssignment1.ts: -------------------------------------------------------------------------------- 1 | var s: string[]; 2 | var n: number[]; 3 | 4 | s = n; -------------------------------------------------------------------------------- /tests/cases/compiler/genericCallWithNonGenericArgs1.ts: -------------------------------------------------------------------------------- 1 | function f(x: any) { } 2 | f(null) 3 | -------------------------------------------------------------------------------- /tests/cases/compiler/nameCollisionsInPropertyAssignments.ts: -------------------------------------------------------------------------------- 1 | var x = 1 2 | var y = { x() { x++; } }; -------------------------------------------------------------------------------- /tests/cases/compiler/newNonReferenceType.ts: -------------------------------------------------------------------------------- 1 | var a = new any(); 2 | var b = new boolean(); // error 3 | -------------------------------------------------------------------------------- /tests/cases/compiler/noCollisionThisExpressionAndVarInGlobal.ts: -------------------------------------------------------------------------------- 1 | var _this = 1; 2 | var f = () => _this; -------------------------------------------------------------------------------- /tests/cases/compiler/numLit.ts: -------------------------------------------------------------------------------- 1 | 1..toString(); 2 | 1.0.toString(); 3 | 1.toString(); 4 | 1.+2.0 + 3. ; -------------------------------------------------------------------------------- /tests/cases/compiler/quotedAccessorName2.ts: -------------------------------------------------------------------------------- 1 | class C { 2 | static get "foo"() { return 0; } 3 | } -------------------------------------------------------------------------------- /tests/cases/compiler/quotedModuleNameMustBeAmbient.ts: -------------------------------------------------------------------------------- 1 | module 'M' {} 2 | 3 | declare module 'M2' {} -------------------------------------------------------------------------------- /tests/cases/compiler/recursiveFunctionTypes1.ts: -------------------------------------------------------------------------------- 1 | class C { 2 | static g(t: typeof C.g){ } 3 | } -------------------------------------------------------------------------------- /tests/cases/compiler/recursiveTypeParameterConstraintReferenceLacksTypeArgs.ts: -------------------------------------------------------------------------------- 1 | class A { } -------------------------------------------------------------------------------- /tests/cases/compiler/typeParametersInStaticProperties.ts: -------------------------------------------------------------------------------- 1 | class foo { 2 | static P: T; 3 | } -------------------------------------------------------------------------------- /tests/cases/compiler/uncaughtCompilerError2.ts: -------------------------------------------------------------------------------- 1 | function getObj() { 2 | ().toString(); 3 | } 4 | -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript3/Accessors/parserES3Accessors3.ts: -------------------------------------------------------------------------------- 1 | var v = { get Foo() { } }; -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript3/Accessors/parserES3Accessors4.ts: -------------------------------------------------------------------------------- 1 | var v = { set Foo(a) { } }; -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/EnumDeclarations/parserEnumDeclaration4.ts: -------------------------------------------------------------------------------- 1 | enum void { 2 | } -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/ErrorRecovery/parserFuzz1.ts: -------------------------------------------------------------------------------- 1 | cla >/**/= 2; -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/Generics/parserGreaterThanTokenAmbiguity14.ts: -------------------------------------------------------------------------------- 1 | 1 >> 2 | = 2; -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/Generics/parserGreaterThanTokenAmbiguity18.ts: -------------------------------------------------------------------------------- 1 | 1 >>>/**/= 2; -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/Generics/parserGreaterThanTokenAmbiguity19.ts: -------------------------------------------------------------------------------- 1 | 1 >>> 2 | = 2; -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/Generics/parserGreaterThanTokenAmbiguity4.ts: -------------------------------------------------------------------------------- 1 | 1 > 2 | > 2; -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/Generics/parserGreaterThanTokenAmbiguity8.ts: -------------------------------------------------------------------------------- 1 | 1 >>/**/> 2; -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/Generics/parserGreaterThanTokenAmbiguity9.ts: -------------------------------------------------------------------------------- 1 | 1 >> 2 | > 2; -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/ParameterLists/parserParameterList11.ts: -------------------------------------------------------------------------------- 1 | (...arg?) => 102; -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/Statements/ReturnStatements/parserReturnStatement1.ts: -------------------------------------------------------------------------------- 1 | return; -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/Statements/parserForInStatement2.ts: -------------------------------------------------------------------------------- 1 | for (var in X) { 2 | } -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/Statements/parserForStatement4.ts: -------------------------------------------------------------------------------- 1 | for (a = 1 in b) { 2 | } -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/Statements/parserForStatement6.ts: -------------------------------------------------------------------------------- 1 | for (foo() in b) { 2 | } -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/Statements/parserForStatement8.ts: -------------------------------------------------------------------------------- 1 | for (this in b) { 2 | } -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/Statements/parserLabeledStatement1.d.ts: -------------------------------------------------------------------------------- 1 | foo: 2 | bar(); -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/Statements/parserSwitchStatement1.d.ts: -------------------------------------------------------------------------------- 1 | switch (foo) { 2 | } -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/Statements/parserWithStatement2.ts: -------------------------------------------------------------------------------- 1 | with (1) 2 | return; -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/StrictMode/parserStrictMode15.ts: -------------------------------------------------------------------------------- 1 | "use strict"; 2 | delete a; -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/StrictMode/parserStrictMode3.ts: -------------------------------------------------------------------------------- 1 | "use strict"; 2 | eval = 1; -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/StrictMode/parserStrictMode5.ts: -------------------------------------------------------------------------------- 1 | "use strict"; 2 | eval += 1; -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/StrictMode/parserStrictMode6.ts: -------------------------------------------------------------------------------- 1 | "use strict"; 2 | eval++; -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/StrictMode/parserStrictMode7.ts: -------------------------------------------------------------------------------- 1 | "use strict"; 2 | ++eval; -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/VariableDeclarations/parserVariableDeclaration10.ts: -------------------------------------------------------------------------------- 1 | var a,; -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/VariableDeclarations/parserVariableDeclaration11.ts: -------------------------------------------------------------------------------- 1 | var a,b; -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/VariableDeclarations/parserVariableDeclaration5.ts: -------------------------------------------------------------------------------- 1 | var a, -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/VariableDeclarations/parserVariableDeclaration7.ts: -------------------------------------------------------------------------------- 1 | var a,b -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/VariableDeclarations/parserVariableDeclaration9.ts: -------------------------------------------------------------------------------- 1 | var a; -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/parserEmptyStatement1.ts: -------------------------------------------------------------------------------- 1 | ; ; 2 | var a = 1; 3 | ; 4 | -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/parserInExpression1.ts: -------------------------------------------------------------------------------- 1 | console.log("a" in { "a": true }); -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/parserUnicodeWhitespaceCharacter1.ts: -------------------------------------------------------------------------------- 1 | function foo(){　} 2 | -------------------------------------------------------------------------------- /tests/cases/conformance/scanner/ecmascript5/scannerStringLiteralWithContainingNullCharacter1.ts: -------------------------------------------------------------------------------- 1 | " "; -------------------------------------------------------------------------------- /tests/cases/fourslash/generated/dummy.txt: -------------------------------------------------------------------------------- 1 | This file is just here so that git will create the directory. -------------------------------------------------------------------------------- /tests/cases/projects/NoModule/foo/bar.ts: -------------------------------------------------------------------------------- 1 | export function call ( ) { 2 | return "hello world"; 3 | } -------------------------------------------------------------------------------- /tests/cases/projects/non-relative/decl.ts: -------------------------------------------------------------------------------- 1 | export function call() { 2 | return "success"; 3 | } -------------------------------------------------------------------------------- /tests/baselines/reference/project/mapRootAbsolutePathModuleMultifolderSpecifyOutputFile/amd/bin/test.d.ts: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /tests/baselines/reference/project/mapRootAbsolutePathModuleMultifolderSpecifyOutputFile/node/bin/test.d.ts: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /tests/baselines/reference/project/mapRootAbsolutePathModuleSubfolderSpecifyOutputFile/node/bin/test.d.ts: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /tests/baselines/reference/project/mapRootRelativePathModuleMultifolderSpecifyOutputFile/amd/bin/test.d.ts: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /tests/baselines/reference/project/mapRootRelativePathModuleMultifolderSpecifyOutputFile/node/bin/test.d.ts: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /tests/baselines/reference/project/mapRootRelativePathModuleSubfolderSpecifyOutputFile/node/bin/test.d.ts: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /tests/baselines/reference/project/maprootUrlsourcerootUrlModuleSimpleSpecifyOutputFile/amd/bin/test.d.ts: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /tests/baselines/reference/project/maprootUrlsourcerootUrlModuleSimpleSpecifyOutputFile/node/bin/test.d.ts: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /tests/baselines/reference/project/maprootUrlsourcerootUrlModuleSubfolderSpecifyOutputFile/amd/bin/test.d.ts: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /tests/baselines/reference/project/maprootUrlsourcerootUrlModuleSubfolderSpecifyOutputFile/node/bin/test.d.ts: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /tests/baselines/reference/project/sourceRootAbsolutePathModuleMultifolderSpecifyOutputFile/amd/bin/test.d.ts: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /tests/baselines/reference/project/sourceRootAbsolutePathModuleSimpleSpecifyOutputFile/node/bin/test.d.ts: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /tests/baselines/reference/project/sourceRootAbsolutePathModuleSubfolderSpecifyOutputFile/amd/bin/test.d.ts: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /tests/baselines/reference/project/sourceRootAbsolutePathModuleSubfolderSpecifyOutputFile/node/bin/test.d.ts: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /tests/baselines/reference/project/sourceRootRelativePathModuleMultifolderSpecifyOutputFile/amd/bin/test.d.ts: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /tests/baselines/reference/project/sourceRootRelativePathModuleSimpleSpecifyOutputFile/node/bin/test.d.ts: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /tests/baselines/reference/project/sourceRootRelativePathModuleSubfolderSpecifyOutputFile/amd/bin/test.d.ts: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /tests/baselines/reference/project/sourceRootRelativePathModuleSubfolderSpecifyOutputFile/node/bin/test.d.ts: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /tests/cases/compiler/FunctionDeclaration6.ts: -------------------------------------------------------------------------------- 1 | { 2 | function foo(); 3 | function bar() { } 4 | } -------------------------------------------------------------------------------- /tests/cases/compiler/MemberAccessorDeclaration15.ts: -------------------------------------------------------------------------------- 1 | class C { 2 | set Foo(public a: number) { } 3 | } -------------------------------------------------------------------------------- /tests/cases/compiler/ParameterList6.ts: -------------------------------------------------------------------------------- 1 | class C { 2 | constructor(C: (public A) => any) { 3 | } 4 | } -------------------------------------------------------------------------------- /tests/cases/compiler/ambientModules.ts: -------------------------------------------------------------------------------- 1 | declare module Foo.Bar { export var foo; }; 2 | Foo.Bar.foo = 5; -------------------------------------------------------------------------------- /tests/cases/compiler/breakInIterationOrSwitchStatement4.ts: -------------------------------------------------------------------------------- 1 | for (var i in something) { 2 | break; 3 | } -------------------------------------------------------------------------------- /tests/cases/compiler/breakTarget3.ts: -------------------------------------------------------------------------------- 1 | target1: 2 | target2: 3 | while (true) { 4 | break target1; 5 | } -------------------------------------------------------------------------------- /tests/cases/compiler/breakTarget4.ts: -------------------------------------------------------------------------------- 1 | target1: 2 | target2: 3 | while (true) { 4 | break target2; 5 | } -------------------------------------------------------------------------------- /tests/cases/compiler/collisionThisExpressionAndClassInGlobal.ts: -------------------------------------------------------------------------------- 1 | class _this { 2 | } 3 | var f = () => this; -------------------------------------------------------------------------------- /tests/cases/compiler/commentOnIfStatement1.ts: -------------------------------------------------------------------------------- 1 | // @comments: true 2 | 3 | // Test 4 | if (true) { 5 | } -------------------------------------------------------------------------------- /tests/cases/compiler/contextualTyping36.ts: -------------------------------------------------------------------------------- 1 | var foo = <{ id: number; }[]>[{ id: 4 }, <{ id: number; }>({ })]; -------------------------------------------------------------------------------- /tests/cases/compiler/continueLabel.ts: -------------------------------------------------------------------------------- 1 | label1: for(var i = 0; i < 1; i++) { 2 | continue label1; 3 | } -------------------------------------------------------------------------------- /tests/cases/compiler/dontShowCompilerGeneratedMembers.ts: -------------------------------------------------------------------------------- 1 | var f: { 2 | x: number; 3 | <- 4 | }; -------------------------------------------------------------------------------- /tests/cases/compiler/enumCodeGenNewLines1.ts: -------------------------------------------------------------------------------- 1 | enum foo { 2 | b = 1, 3 | c = 2, 4 | d = 3 5 | } 6 | -------------------------------------------------------------------------------- /tests/cases/compiler/enumsWithMultipleDeclarations3.ts: -------------------------------------------------------------------------------- 1 | module E { 2 | } 3 | 4 | enum E { 5 | A 6 | } -------------------------------------------------------------------------------- /tests/cases/compiler/errorTypesAsTypeArguments.ts: -------------------------------------------------------------------------------- 1 | interface Foo { 2 | bar(baz: Foo): Foo; 3 | } -------------------------------------------------------------------------------- /tests/cases/compiler/exportAssignmentWithDeclareAndExportModifiers.ts: -------------------------------------------------------------------------------- 1 | var x; 2 | export declare export = x; -------------------------------------------------------------------------------- /tests/cases/compiler/functionOverloads4.ts: -------------------------------------------------------------------------------- 1 | function foo():number; 2 | function foo():string { return "a" } -------------------------------------------------------------------------------- /tests/cases/compiler/idInProp.ts: -------------------------------------------------------------------------------- 1 | function f() { 2 | 3 | var t: { (f: any) : any; }; 4 | 5 | } 6 | -------------------------------------------------------------------------------- /tests/cases/compiler/interfaceNaming1.ts: -------------------------------------------------------------------------------- 1 | interface { } 2 | interface interface{ } 3 | interface & { } 4 | -------------------------------------------------------------------------------- /tests/cases/compiler/modKeyword.ts: -------------------------------------------------------------------------------- 1 | var module:any; 2 | var foo:any; 3 | 4 | var _ = module.exports = foo -------------------------------------------------------------------------------- /tests/cases/compiler/nestedGenerics.ts: -------------------------------------------------------------------------------- 1 | interface Foo { 2 | t: T; 3 | } 4 | 5 | var f: Foo>; -------------------------------------------------------------------------------- /tests/cases/compiler/overloadOnConstAsTypeAnnotation.ts: -------------------------------------------------------------------------------- 1 | var f: (x: 'hi') => number = ('hi') => { return 1; }; -------------------------------------------------------------------------------- /tests/cases/compiler/recursiveBaseCheck6.ts: -------------------------------------------------------------------------------- 1 | class S18 extends S18<{ S19: A; }>{ } 2 | (new S18()).blah; -------------------------------------------------------------------------------- /tests/cases/compiler/thisExpressionInIndexExpression.ts: -------------------------------------------------------------------------------- 1 | function f() { 2 | return r => r[this]; 3 | } -------------------------------------------------------------------------------- /tests/cases/compiler/typeInferenceFixEarly.ts: -------------------------------------------------------------------------------- 1 | declare function f(p: (t: T) => T): T; 2 | 3 | f(n => 3); -------------------------------------------------------------------------------- /tests/cases/compiler/typeParameterAsBaseClass.ts: -------------------------------------------------------------------------------- 1 | class C extends T {} 2 | class C2 implements T {} -------------------------------------------------------------------------------- /tests/cases/compiler/voidOperator1.ts: -------------------------------------------------------------------------------- 1 | var x: any = void 1; 2 | var y: void = void 1; 3 | var z = void 1; -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/ClassDeclarations/parserClassDeclaration24.ts: -------------------------------------------------------------------------------- 1 | class any { 2 | } -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/EnumDeclarations/parserEnum7.ts: -------------------------------------------------------------------------------- 1 | enum E { 2 | 1, 2, 3 3 | } -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/ErrorRecovery/parserEqualsGreaterThanAfterFunction1.ts: -------------------------------------------------------------------------------- 1 | function => -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/FunctionDeclarations/parserFunctionDeclaration3.ts: -------------------------------------------------------------------------------- 1 | function foo(); -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/ModuleDeclarations/parserModuleDeclaration2.d.ts: -------------------------------------------------------------------------------- 1 | module M { 2 | } -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/ObjectLiterals/parserObjectLiterals1.ts: -------------------------------------------------------------------------------- 1 | var v = { a: 1, b: 2 }; -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/ParameterLists/parserParameterList12.ts: -------------------------------------------------------------------------------- 1 | function F(a,) { 2 | } -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/RegressionTests/parser512325.ts: -------------------------------------------------------------------------------- 1 | var tt = (a, (b, c)) => a+b+c; -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/RegressionTests/parser537152.ts: -------------------------------------------------------------------------------- 1 | var t; 2 | var y = t.e1; 3 | -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/SkippedTokens/parserSkippedTokens8.ts: -------------------------------------------------------------------------------- 1 | ; 2 | /*foo*/ \ /*bar*/ -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/Statements/parserDoStatement1.d.ts: -------------------------------------------------------------------------------- 1 | do { 2 | } 3 | while (e); -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/Statements/parserForInStatement1.d.ts: -------------------------------------------------------------------------------- 1 | for (var i in e) { 2 | } -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/Statements/parserForInStatement3.ts: -------------------------------------------------------------------------------- 1 | for (var a, b in X) { 2 | } -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/Statements/parserForInStatement4.ts: -------------------------------------------------------------------------------- 1 | for (var a = 1 in X) { 2 | } -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/Statements/parserForStatement3.ts: -------------------------------------------------------------------------------- 1 | for(d in _.jh[a]=_.jh[a]||[],b); -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/Statements/parserForStatement7.ts: -------------------------------------------------------------------------------- 1 | for (new foo() in b) { 2 | } -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/StrictMode/octalLiteralInStrictModeES3.ts: -------------------------------------------------------------------------------- 1 | "use strict"; 2 | 03; -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/StrictMode/parserStrictMode4.ts: -------------------------------------------------------------------------------- 1 | "use strict"; 2 | arguments = 1; -------------------------------------------------------------------------------- /tests/cases/fourslash/todoComments13.ts: -------------------------------------------------------------------------------- 1 | //// TODO 2 | 3 | verify.todoCommentsInCurrentFile(["TODO"]); -------------------------------------------------------------------------------- /tests/cases/projects/reference-path-static/lib.ts: -------------------------------------------------------------------------------- 1 | module Lib { 2 | export class LibType {} 3 | } 4 | -------------------------------------------------------------------------------- /tests/cases/unittests/services/formatting/testCode/testCode/formatting/onSemiColon.ts: -------------------------------------------------------------------------------- 1 | var a=b+c^d-e*++f; -------------------------------------------------------------------------------- /tests/baselines/reference/project/maprootUrlsourcerootUrlModuleMultifolderSpecifyOutputFile/amd/bin/test.d.ts: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /tests/baselines/reference/project/maprootUrlsourcerootUrlModuleMultifolderSpecifyOutputFile/node/bin/test.d.ts: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /tests/baselines/reference/project/sourceRootAbsolutePathModuleMultifolderSpecifyOutputFile/node/bin/test.d.ts: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /tests/baselines/reference/project/sourceRootRelativePathModuleMultifolderSpecifyOutputFile/node/bin/test.d.ts: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /tests/cases/compiler/arrayConcatMap.ts: -------------------------------------------------------------------------------- 1 | var x = [].concat([{ a: 1 }], [{ a: 2 }]) 2 | .map(b => b.a); -------------------------------------------------------------------------------- /tests/cases/compiler/autoAsiForStaticsInClassDeclaration.ts: -------------------------------------------------------------------------------- 1 | class C { 2 | static x 3 | static y 4 | } -------------------------------------------------------------------------------- /tests/cases/compiler/classExtendsMultipleBaseClasses.ts: -------------------------------------------------------------------------------- 1 | class A { } 2 | class B { } 3 | class C extends A,B { } -------------------------------------------------------------------------------- /tests/cases/compiler/commentInEmptyParameterList1.ts: -------------------------------------------------------------------------------- 1 | // @comments:true 2 | function foo(/** nothing */) { 3 | } -------------------------------------------------------------------------------- /tests/cases/compiler/contextualTyping12.ts: -------------------------------------------------------------------------------- 1 | class foo { public bar:{id:number;}[] = [{id:1}, {id:2, name:"foo"}]; } -------------------------------------------------------------------------------- /tests/cases/compiler/contextualTyping14.ts: -------------------------------------------------------------------------------- 1 | class foo { public bar:(a:number)=>number = function(a){return a}; } -------------------------------------------------------------------------------- /tests/cases/compiler/contextualTyping20.ts: -------------------------------------------------------------------------------- 1 | var foo:{id:number;}[] = [{id:1}]; foo = [{id:1}, {id:2, name:"foo"}]; -------------------------------------------------------------------------------- /tests/cases/compiler/contextualTyping40.ts: -------------------------------------------------------------------------------- 1 | var foo = <{():number; (i:number):number; }> function(){return 1;}; -------------------------------------------------------------------------------- /tests/cases/compiler/continueNotInIterationStatement3.ts: -------------------------------------------------------------------------------- 1 | switch (0) { 2 | default: 3 | continue; 4 | } -------------------------------------------------------------------------------- /tests/cases/compiler/continueTarget3.ts: -------------------------------------------------------------------------------- 1 | target1: 2 | target2: 3 | while (true) { 4 | continue target1; 5 | } -------------------------------------------------------------------------------- /tests/cases/compiler/continueTarget4.ts: -------------------------------------------------------------------------------- 1 | target1: 2 | target2: 3 | while (true) { 4 | continue target2; 5 | } -------------------------------------------------------------------------------- /tests/cases/compiler/crashOnMethodSignatures.ts: -------------------------------------------------------------------------------- 1 | class A { 2 | a(completed: () => any): void; 3 | } 4 | -------------------------------------------------------------------------------- /tests/cases/compiler/duplicateConstructSignature.ts: -------------------------------------------------------------------------------- 1 | interface I { 2 | (): number; 3 | (): string; 4 | } -------------------------------------------------------------------------------- /tests/cases/compiler/duplicateLocalVariable4.ts: -------------------------------------------------------------------------------- 1 | enum E{ 2 | a 3 | } 4 | 5 | var x = E; 6 | var x = E.a; -------------------------------------------------------------------------------- /tests/cases/compiler/duplicateTypeParameters3.ts: -------------------------------------------------------------------------------- 1 | interface X { 2 | x: () => () => void; 3 | } 4 | 5 | -------------------------------------------------------------------------------- /tests/cases/compiler/emptyMemberAccess.ts: -------------------------------------------------------------------------------- 1 | function getObj() { 2 | 3 | ().toString(); 4 | 5 | } 6 | -------------------------------------------------------------------------------- /tests/cases/compiler/externFunc.ts: -------------------------------------------------------------------------------- 1 | declare function parseInt(s:string):number; 2 | 3 | parseInt("2"); 4 | -------------------------------------------------------------------------------- /tests/cases/compiler/externSemantics.ts: -------------------------------------------------------------------------------- 1 | declare var x=10; 2 | declare var v; 3 | declare var y:number=3; 4 | -------------------------------------------------------------------------------- /tests/cases/compiler/forInModule.ts: -------------------------------------------------------------------------------- 1 | module Foo { 2 | for (var i = 0; i < 1; i++) { 3 | i+i; 4 | } 5 | } -------------------------------------------------------------------------------- /tests/cases/compiler/functionOverloads1.ts: -------------------------------------------------------------------------------- 1 | function foo(); 2 | 1+1; 3 | function foo():string { return "a" } -------------------------------------------------------------------------------- /tests/cases/compiler/functionOverloads11.ts: -------------------------------------------------------------------------------- 1 | function foo():number; 2 | function foo():string { return "" } 3 | -------------------------------------------------------------------------------- /tests/cases/compiler/genericArrayMethods1.ts: -------------------------------------------------------------------------------- 1 | var x:string[] = [0,1].slice(0); // this should be an error 2 | -------------------------------------------------------------------------------- /tests/cases/compiler/genericCallWithoutArgs.ts: -------------------------------------------------------------------------------- 1 | function f(x: X, y: Y) { 2 | } 3 | 4 | f. -------------------------------------------------------------------------------- /tests/cases/compiler/indexIntoEnum.ts: -------------------------------------------------------------------------------- 1 | module M { 2 | 3 | enum E { } 4 | 5 | var x = E[0]; 6 | } -------------------------------------------------------------------------------- /tests/cases/compiler/indirectSelfReferenceGeneric.ts: -------------------------------------------------------------------------------- 1 | class a extends b { } 2 | class b extends a { } -------------------------------------------------------------------------------- /tests/cases/compiler/inheritFromGenericTypeParameter.ts: -------------------------------------------------------------------------------- 1 | class C extends T { } 2 | interface I extends T { } -------------------------------------------------------------------------------- /tests/cases/compiler/mismatchedClassConstructorVariable.ts: -------------------------------------------------------------------------------- 1 | var baz: foo; 2 | class baz { } 3 | class foo { } -------------------------------------------------------------------------------- /tests/cases/compiler/moduleCodeGenTest3.ts: -------------------------------------------------------------------------------- 1 | module Baz { export var x = "hello"; } 2 | 3 | Baz.x = "goodbye"; -------------------------------------------------------------------------------- /tests/cases/compiler/noCollisionThisExpressionAndClassInGlobal.ts: -------------------------------------------------------------------------------- 1 | class _this { 2 | } 3 | var f = () => _this; -------------------------------------------------------------------------------- /tests/cases/compiler/noImplicitAnyStringIndexerOnObject.ts: -------------------------------------------------------------------------------- 1 | // @noimplicitany: true 2 | 3 | var x = {}["hello"]; -------------------------------------------------------------------------------- /tests/cases/compiler/numberOnLeftSideOfInExpression.ts: -------------------------------------------------------------------------------- 1 | var left: number; 2 | var right: any; 3 | left in right; -------------------------------------------------------------------------------- /tests/cases/compiler/objectLiteralDeclarationGeneration1.ts: -------------------------------------------------------------------------------- 1 | // @declaration: true 2 | class y{ } -------------------------------------------------------------------------------- /tests/cases/compiler/optionalSetterParam.ts: -------------------------------------------------------------------------------- 1 | class foo { 2 | 3 | public set bar(param?:any) { } 4 | } 5 | -------------------------------------------------------------------------------- /tests/cases/compiler/parameterPropertyOutsideConstructor.ts: -------------------------------------------------------------------------------- 1 | class C { 2 | foo(public x) { 3 | } 4 | } -------------------------------------------------------------------------------- /tests/cases/compiler/recursiveInheritanceGeneric.ts: -------------------------------------------------------------------------------- 1 | interface I5 extends I5 { 2 | foo():void; 3 | } -------------------------------------------------------------------------------- /tests/cases/compiler/staticAndMemberFunctions.ts: -------------------------------------------------------------------------------- 1 | class T { 2 | static x() { } 3 | public y() { } 4 | } -------------------------------------------------------------------------------- /tests/cases/compiler/staticInstanceResolution4.ts: -------------------------------------------------------------------------------- 1 | class A { 2 | public foo() {} 3 | } 4 | 5 | A.foo(); -------------------------------------------------------------------------------- /tests/cases/compiler/strictMode2.ts: -------------------------------------------------------------------------------- 1 | "use strict"; 2 | 3 | function foo() { 4 | 5 | return 30; 6 | } -------------------------------------------------------------------------------- /tests/cases/compiler/typeOfOperator1.ts: -------------------------------------------------------------------------------- 1 | var x = 1; 2 | var y: string = typeof x; 3 | var z: number = typeof x; -------------------------------------------------------------------------------- /tests/cases/compiler/typeofUnknownSymbol.ts: -------------------------------------------------------------------------------- 1 | // previously gave no error here 2 | var x = typeof whatsthis 3 | -------------------------------------------------------------------------------- /tests/cases/compiler/validRegexp.ts: -------------------------------------------------------------------------------- 1 | var x = / [a - z /]$ / i; 2 | var x1 = /[a-z/]$/i; 3 | var x2 = /[a-z/]$ /i; -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/ArrayLiteralExpressions/parserArrayLiteralExpression1.ts: -------------------------------------------------------------------------------- 1 | var v = []; -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/ArrayLiteralExpressions/parserArrayLiteralExpression2.ts: -------------------------------------------------------------------------------- 1 | var v = [,]; -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/ArrayLiteralExpressions/parserArrayLiteralExpression3.ts: -------------------------------------------------------------------------------- 1 | var v = [,,]; -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/ArrayLiteralExpressions/parserArrayLiteralExpression4.ts: -------------------------------------------------------------------------------- 1 | var v = [,,,]; -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/ArrayLiteralExpressions/parserArrayLiteralExpression5.ts: -------------------------------------------------------------------------------- 1 | var v = [1]; -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/ArrayLiteralExpressions/parserArrayLiteralExpression6.ts: -------------------------------------------------------------------------------- 1 | var v = [,1]; -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/ArrayLiteralExpressions/parserArrayLiteralExpression7.ts: -------------------------------------------------------------------------------- 1 | var v = [1,]; -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/ArrayLiteralExpressions/parserArrayLiteralExpression8.ts: -------------------------------------------------------------------------------- 1 | var v = [,1,]; -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/ArrayLiteralExpressions/parserArrayLiteralExpression9.ts: -------------------------------------------------------------------------------- 1 | var v = [1,1]; -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/ClassDeclarations/parserClassDeclaration23.ts: -------------------------------------------------------------------------------- 1 | class C\u0032 { 2 | } -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/ClassDeclarations/parserClassDeclaration7.d.ts: -------------------------------------------------------------------------------- 1 | declare class C { 2 | } -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/EnumDeclarations/parserEnum6.ts: -------------------------------------------------------------------------------- 1 | enum E { 2 | "A", "B", "C" 3 | } -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/EnumDeclarations/parserEnumDeclaration2.d.ts: -------------------------------------------------------------------------------- 1 | declare enum E { 2 | } -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/ErrorRecovery/ArgumentLists/parserErrorRecovery_ArgumentList6.ts: -------------------------------------------------------------------------------- 1 | Foo(, -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/Expressions/parserMemberAccessAfterPostfixExpression1.ts: -------------------------------------------------------------------------------- 1 | a--.toString() -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/Generics/parserGenericConstraint1.ts: -------------------------------------------------------------------------------- 1 | class C { 2 | } -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/ModuleDeclarations/parserModuleDeclaration1.d.ts: -------------------------------------------------------------------------------- 1 | module "Foo" { 2 | } -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/ModuleDeclarations/parserModuleDeclaration1.ts: -------------------------------------------------------------------------------- 1 | module "Foo" { 2 | } -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/ModuleDeclarations/parserModuleDeclaration6.ts: -------------------------------------------------------------------------------- 1 | module number { 2 | } -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/ModuleDeclarations/parserModuleDeclaration7.ts: -------------------------------------------------------------------------------- 1 | module number.a { 2 | } -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/ModuleDeclarations/parserModuleDeclaration8.ts: -------------------------------------------------------------------------------- 1 | module a.number { 2 | } -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/ObjectTypes/parserObjectType3.ts: -------------------------------------------------------------------------------- 1 | var v: { 2 | x; 3 | y 4 | }; -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/ObjectTypes/parserObjectType4.ts: -------------------------------------------------------------------------------- 1 | var v: { 2 | x 3 | y 4 | }; -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/ParameterLists/parserParameterList4.ts: -------------------------------------------------------------------------------- 1 | function F(public A) { 2 | } -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/RegressionTests/parser645484.ts: -------------------------------------------------------------------------------- 1 | var c : { 2 | new?(): any; 3 | } -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/RegularExpressions/parserRegularExpression3.ts: -------------------------------------------------------------------------------- 1 | Foo(!/(\\?|&)adurl=/); -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/Statements/parserForInStatement5.ts: -------------------------------------------------------------------------------- 1 | for (var a: number in X) { 2 | } -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/StrictMode/parserStrictMode14.ts: -------------------------------------------------------------------------------- 1 | "use strict"; 2 | with (a) { 3 | } -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/VariableDeclarations/parserVariableDeclaration4.d.ts: -------------------------------------------------------------------------------- 1 | declare var v; -------------------------------------------------------------------------------- /tests/cases/conformance/types/primitives/void/validVoidValues.ts: -------------------------------------------------------------------------------- 1 | var x: void; 2 | x = undefined; 3 | x = null; -------------------------------------------------------------------------------- /tests/cases/fourslash/todoComments1.ts: -------------------------------------------------------------------------------- 1 | //// // [|TODO|] 2 | 3 | verify.todoCommentsInCurrentFile(["TODO"]); -------------------------------------------------------------------------------- /tests/cases/fourslash/todoComments2.ts: -------------------------------------------------------------------------------- 1 | //// // not TODO 2 | 3 | verify.todoCommentsInCurrentFile(["TODO"]); -------------------------------------------------------------------------------- /tests/cases/fourslash/todoComments4.ts: -------------------------------------------------------------------------------- 1 | //// // TODOnomatch 2 | 3 | verify.todoCommentsInCurrentFile(["TODO"]); -------------------------------------------------------------------------------- /tests/cases/projects/ModuleIdentifier/decl.ts: -------------------------------------------------------------------------------- 1 | export interface P { x: number; y: number; } 2 | export var a = 1; -------------------------------------------------------------------------------- /tests/cases/projects/baseline/dont_emit.ts: -------------------------------------------------------------------------------- 1 | import g = require("decl"); 2 | var p: g.Point = { x: 10, y: 20 }; -------------------------------------------------------------------------------- /tests/cases/projects/ext-int-ext/external2.ts: -------------------------------------------------------------------------------- 1 | export function square(x: number) { 2 | return (x * x); 3 | } -------------------------------------------------------------------------------- /tests/cases/projects/privacyCheck-IndirectReference/indirectExternalModule.ts: -------------------------------------------------------------------------------- 1 | export class indirectClass { 2 | } -------------------------------------------------------------------------------- /tests/cases/projects/relative-nested/app.ts: -------------------------------------------------------------------------------- 1 | import consume = require("./main/consume"); 2 | 3 | consume.call(); -------------------------------------------------------------------------------- /tests/cases/unittests/services/formatting/testCode/formatting/onSemiColonBaseline.ts: -------------------------------------------------------------------------------- 1 | var a = b + c ^ d - e * ++f; -------------------------------------------------------------------------------- /tests/baselines/reference/emptyExpr.js: -------------------------------------------------------------------------------- 1 | //// [emptyExpr.ts] 2 | [{},] 3 | 4 | //// [emptyExpr.js] 5 | [{},]; 6 | -------------------------------------------------------------------------------- /tests/baselines/reference/project/baseline/node/emit.js: -------------------------------------------------------------------------------- 1 | var g = require("./decl"); 2 | var p = g.point(10, 20); 3 | -------------------------------------------------------------------------------- /tests/cases/compiler/ambientClassDeclarationWithExtends.ts: -------------------------------------------------------------------------------- 1 | declare class A { } 2 | declare class B extends A { } 3 | -------------------------------------------------------------------------------- /tests/cases/compiler/ambientClassOverloadForFunction.ts: -------------------------------------------------------------------------------- 1 | declare class foo{}; 2 | function foo() { return null; } 3 | -------------------------------------------------------------------------------- /tests/cases/compiler/catch.ts: -------------------------------------------------------------------------------- 1 | function f() { 2 | try {} catch(e) { } 3 | try {} catch(e) { } 4 | } 5 | -------------------------------------------------------------------------------- /tests/cases/compiler/classHeritageWithTrailingSeparator.ts: -------------------------------------------------------------------------------- 1 | class C { foo: number } 2 | class D extends C, { 3 | } -------------------------------------------------------------------------------- /tests/cases/compiler/compoundVarDecl1.ts: -------------------------------------------------------------------------------- 1 | module Foo { var a = 1, b = 1; a = b + 2; } 2 | 3 | var foo = 4, bar = 5; -------------------------------------------------------------------------------- /tests/cases/compiler/constructorArgsErrors1.ts: -------------------------------------------------------------------------------- 1 | class foo { 2 | constructor (static a: number) { 3 | } 4 | } -------------------------------------------------------------------------------- /tests/cases/compiler/contextualTyping41.ts: -------------------------------------------------------------------------------- 1 | var foo = <{():number; (i:number):number; }> (function(){return "err";}); -------------------------------------------------------------------------------- /tests/cases/compiler/defaultValueInFunctionOverload1.ts: -------------------------------------------------------------------------------- 1 | function foo(x: string = ''); 2 | function foo(x = '') { } -------------------------------------------------------------------------------- /tests/cases/compiler/duplicateInterfaceMembers1.ts: -------------------------------------------------------------------------------- 1 | interface Bar { 2 | x: number; 3 | x: number; 4 | } 5 | -------------------------------------------------------------------------------- /tests/cases/compiler/duplicatePropertiesInStrictMode.ts: -------------------------------------------------------------------------------- 1 | "use strict"; 2 | var x = { 3 | x: 1, 4 | x: 2 5 | } -------------------------------------------------------------------------------- /tests/cases/compiler/errorLocationForInterfaceExtension.ts: -------------------------------------------------------------------------------- 1 | var n = ''; 2 | 3 | interface x extends string { } 4 | -------------------------------------------------------------------------------- /tests/cases/compiler/exportSameNameFuncVar.ts: -------------------------------------------------------------------------------- 1 | //@module: amd 2 | export var a = 10; 3 | export function a() { 4 | } -------------------------------------------------------------------------------- /tests/cases/compiler/getterMissingReturnError.ts: -------------------------------------------------------------------------------- 1 | class test { 2 | public get p2(){ 3 | 4 | } 5 | } 6 | -------------------------------------------------------------------------------- /tests/cases/compiler/implementClausePrecedingExtends.ts: -------------------------------------------------------------------------------- 1 | class C { foo: number } 2 | class D implements C extends C { } -------------------------------------------------------------------------------- /tests/cases/compiler/interfaceWithImplements1.ts: -------------------------------------------------------------------------------- 1 | interface IFoo { } 2 | 3 | interface IBar implements IFoo { 4 | } -------------------------------------------------------------------------------- /tests/cases/compiler/invalidReferenceSyntax1.ts: -------------------------------------------------------------------------------- 1 | /// ; 4 | }; -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/ObjectTypes/parserObjectType6.ts: -------------------------------------------------------------------------------- 1 | var v: { 2 | a: B 3 | []; 4 | }; -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/ParameterLists/parserParameterList2.ts: -------------------------------------------------------------------------------- 1 | class C { 2 | F(A?= 0) { } 3 | } -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/ParameterLists/parserParameterList3.ts: -------------------------------------------------------------------------------- 1 | class C { 2 | F(A?, B) { } 3 | } -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/Protected/Protected3.ts: -------------------------------------------------------------------------------- 1 | class C { 2 | protected constructor() { } 3 | } -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/Protected/Protected4.ts: -------------------------------------------------------------------------------- 1 | class C { 2 | protected public m() { } 3 | } -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/Protected/Protected5.ts: -------------------------------------------------------------------------------- 1 | class C { 2 | protected static m() { } 3 | } -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/Protected/Protected6.ts: -------------------------------------------------------------------------------- 1 | class C { 2 | static protected m() { } 3 | } -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/Protected/Protected7.ts: -------------------------------------------------------------------------------- 1 | class C { 2 | protected private m() { } 3 | } -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/Protected/Protected8.ts: -------------------------------------------------------------------------------- 1 | interface I { 2 | protected 3 | p 4 | } -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/RegressionTests/parser509693.ts: -------------------------------------------------------------------------------- 1 | if (!module.exports) module.exports = ""; -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/Statements/parserForInStatement6.ts: -------------------------------------------------------------------------------- 1 | for (var a = 1, b = 2 in X) { 2 | } -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/Statements/parserTryStatement1.d.ts: -------------------------------------------------------------------------------- 1 | try { 2 | } 3 | catch (e) { 4 | } -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/StrictMode/parserStrictMode15-negative.ts: -------------------------------------------------------------------------------- 1 | "use strict"; 2 | delete a[b]; -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/StrictMode/parserStrictMode8.ts: -------------------------------------------------------------------------------- 1 | "use strict"; 2 | function eval() { 3 | } -------------------------------------------------------------------------------- /tests/cases/conformance/statements/throwStatements/invalidThrowStatement.ts: -------------------------------------------------------------------------------- 1 | throw; 2 | 3 | export throw null; 4 | -------------------------------------------------------------------------------- /tests/cases/conformance/types/primitives/undefined/validUndefinedValues.ts: -------------------------------------------------------------------------------- 1 | var x: typeof undefined; 2 | x = undefined; -------------------------------------------------------------------------------- /tests/cases/fourslash/todoComments14.ts: -------------------------------------------------------------------------------- 1 | //// BAR // [|TODO|] 2 | 3 | verify.todoCommentsInCurrentFile(["TODO"]); -------------------------------------------------------------------------------- /tests/cases/projects/DeclareExportAdded/ref.d.ts: -------------------------------------------------------------------------------- 1 | declare module M1 2 | { 3 | export function f1(): void; 4 | } -------------------------------------------------------------------------------- /tests/cases/projects/RelativePaths/b.ts: -------------------------------------------------------------------------------- 1 | export function B(): void { 2 | throw new Error('Must be called'); 3 | } -------------------------------------------------------------------------------- /tests/cases/projects/non-relative/lib/foo/a.ts: -------------------------------------------------------------------------------- 1 | import b = require("lib/foo/b"); 2 | export function hello() { } 3 | -------------------------------------------------------------------------------- /tests/cases/projects/relative-global-ref/decl.d.ts: -------------------------------------------------------------------------------- 1 | declare module "decl" 2 | { 3 | export function call(); 4 | } -------------------------------------------------------------------------------- /tests/cases/projects/relative-nested-ref/decl.d.ts: -------------------------------------------------------------------------------- 1 | declare module "decl" 2 | { 3 | export function call(); 4 | } -------------------------------------------------------------------------------- /tests/baselines/reference/bind2.types: -------------------------------------------------------------------------------- 1 | === tests/cases/compiler/bind2.ts === 2 | 3 | No type information for this code. -------------------------------------------------------------------------------- /tests/baselines/reference/emptyEnum.types: -------------------------------------------------------------------------------- 1 | === tests/cases/compiler/emptyEnum.ts === 2 | enum E { 3 | >E : E 4 | } 5 | -------------------------------------------------------------------------------- /tests/baselines/reference/getEmitOutputWithSyntaxErrors.baseline: -------------------------------------------------------------------------------- 1 | EmitOutputStatus : AllOutputGenerationSkipped 2 | 3 | -------------------------------------------------------------------------------- /tests/baselines/reference/parserEmptyFile1.js: -------------------------------------------------------------------------------- 1 | //// [parserEmptyFile1.ts] 2 | 3 | 4 | //// [parserEmptyFile1.js] 5 | -------------------------------------------------------------------------------- /tests/baselines/reference/project/nonRelative/node/lib/bar/a.js: -------------------------------------------------------------------------------- 1 | function hello() { 2 | } 3 | exports.hello = hello; 4 | -------------------------------------------------------------------------------- /tests/baselines/reference/project/nonRelative/node/lib/foo/a.js: -------------------------------------------------------------------------------- 1 | function hello() { 2 | } 3 | exports.hello = hello; 4 | -------------------------------------------------------------------------------- /tests/baselines/reference/project/nonRelative/node/lib/foo/b.js: -------------------------------------------------------------------------------- 1 | function hello() { 2 | } 3 | exports.hello = hello; 4 | -------------------------------------------------------------------------------- /tests/baselines/reference/project/sourcemapModuleSimpleSpecifyOutputFile/amd/bin/test.js: -------------------------------------------------------------------------------- 1 | //# sourceMappingURL=test.js.map -------------------------------------------------------------------------------- /tests/baselines/reference/project/sourcemapModuleSimpleSpecifyOutputFile/node/bin/test.js: -------------------------------------------------------------------------------- 1 | //# sourceMappingURL=test.js.map -------------------------------------------------------------------------------- /tests/baselines/reference/project/sourcemapModuleSubfolderSpecifyOutputFile/amd/bin/test.js: -------------------------------------------------------------------------------- 1 | //# sourceMappingURL=test.js.map -------------------------------------------------------------------------------- /tests/cases/compiler/ambientFundule.ts: -------------------------------------------------------------------------------- 1 | declare function f(); 2 | declare module f { var x } 3 | declare function f(x); -------------------------------------------------------------------------------- /tests/cases/compiler/assignmentCompat1.ts: -------------------------------------------------------------------------------- 1 | var x = {one: 1}; 2 | var y: {[index:string]: any}; 3 | 4 | x = y; 5 | y = x; -------------------------------------------------------------------------------- /tests/cases/compiler/classIndexer.ts: -------------------------------------------------------------------------------- 1 | class C123 { 2 | [s: string]: number; 3 | constructor() { 4 | } 5 | } -------------------------------------------------------------------------------- /tests/cases/compiler/constructorArgsErrors5.ts: -------------------------------------------------------------------------------- 1 | class foo { 2 | constructor (export a: number) { 3 | } 4 | } 5 | -------------------------------------------------------------------------------- /tests/cases/compiler/contextualTyping22.ts: -------------------------------------------------------------------------------- 1 | var foo:(a:number)=>number = function(a){return a}; foo = function(b){return b}; -------------------------------------------------------------------------------- /tests/cases/compiler/duplicateLabel2.ts: -------------------------------------------------------------------------------- 1 | target: 2 | while (true) { 3 | target: 4 | while (true) { 5 | } 6 | } -------------------------------------------------------------------------------- /tests/cases/compiler/duplicateLabel4.ts: -------------------------------------------------------------------------------- 1 | target: 2 | while (true) { 3 | } 4 | 5 | target: 6 | while (true) { 7 | } -------------------------------------------------------------------------------- /tests/cases/compiler/enumWithoutInitializerAfterComputedMember.ts: -------------------------------------------------------------------------------- 1 | enum E { 2 | a, 3 | b = a, 4 | c 5 | } -------------------------------------------------------------------------------- /tests/cases/compiler/forInStatement3.ts: -------------------------------------------------------------------------------- 1 | function F() { 2 | var expr: T; 3 | for (var a in expr) { 4 | } 5 | } -------------------------------------------------------------------------------- /tests/cases/compiler/functionOnlyHasThrow.ts: -------------------------------------------------------------------------------- 1 | function clone():number { 2 | throw new Error("To be implemented"); 3 | } -------------------------------------------------------------------------------- /tests/cases/compiler/functionOverloads5.ts: -------------------------------------------------------------------------------- 1 | class baz { 2 | public foo(); 3 | private foo(bar?:any){ } 4 | } 5 | -------------------------------------------------------------------------------- /tests/cases/compiler/genericFunctionHasFreshTypeArgs.ts: -------------------------------------------------------------------------------- 1 | function f(p: (x: T) => void) { }; 2 | f(x => f(y => x = y)); -------------------------------------------------------------------------------- /tests/cases/compiler/genericTypeUsedWithoutTypeArguments1.ts: -------------------------------------------------------------------------------- 1 | interface Foo { } 2 | class Bar implements Foo { } 3 | -------------------------------------------------------------------------------- /tests/cases/compiler/illegalModifiersOnClassElements.ts: -------------------------------------------------------------------------------- 1 | class C { 2 | declare foo = 1; 3 | export bar = 1; 4 | } -------------------------------------------------------------------------------- /tests/cases/compiler/incompleteDottedExpressionAtEOF.ts: -------------------------------------------------------------------------------- 1 | // used to leak __missing into error message 2 | var p2 = window. -------------------------------------------------------------------------------- /tests/cases/compiler/invalidStaticField.ts: -------------------------------------------------------------------------------- 1 | class A { foo() { return B.NULL; } } 2 | class B { static NOT_NULL = new B(); } -------------------------------------------------------------------------------- /tests/cases/compiler/newOnInstanceSymbol.ts: -------------------------------------------------------------------------------- 1 | class C {} 2 | var x = new C(); // should be ok 3 | new x(); // should error -------------------------------------------------------------------------------- /tests/cases/compiler/noTypeArgumentOnReturnType1.ts: -------------------------------------------------------------------------------- 1 | class A{ 2 | 3 | foo(): A{ 4 | return null; 5 | } 6 | } -------------------------------------------------------------------------------- /tests/cases/compiler/optionalParamReferencingOtherParams3.ts: -------------------------------------------------------------------------------- 1 | function right(a = b, b = a) { 2 | a; 3 | b; 4 | } -------------------------------------------------------------------------------- /tests/cases/compiler/recursiveGenericSignatureInstantiation.ts: -------------------------------------------------------------------------------- 1 | function f6(x: T) { 2 | return f6(x); 3 | } 4 | -------------------------------------------------------------------------------- /tests/cases/compiler/simpleArrowFunctionParameterReferencedInObjectLiteral1.ts: -------------------------------------------------------------------------------- 1 | [].map(() => [].map(p => ({ X: p }))); 2 | -------------------------------------------------------------------------------- /tests/cases/compiler/stringIndexerAndConstructor1.ts: -------------------------------------------------------------------------------- 1 | interface I { 2 | [s: string]: number; 3 | "": string; 4 | } -------------------------------------------------------------------------------- /tests/cases/compiler/typeParameterAsElementType.ts: -------------------------------------------------------------------------------- 1 | function fee() { 2 | var t: T; 3 | var arr = [t, ""]; 4 | } -------------------------------------------------------------------------------- /tests/cases/compiler/variableDeclarator1.ts: -------------------------------------------------------------------------------- 1 | var a = function () { 2 | var c = 1; 3 | return c; 4 | }; -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/Accessors/parserAccessors3.ts: -------------------------------------------------------------------------------- 1 | // @target: es5 2 | var v = { get Foo() { } }; -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/Accessors/parserAccessors4.ts: -------------------------------------------------------------------------------- 1 | // @target: es5 2 | var v = { set Foo(a) { } }; -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/Accessors/parserAccessors9.ts: -------------------------------------------------------------------------------- 1 | // @target: es5 2 | var v = { set foo(a, b) { } } -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/ArrowFunctionExpressions/parserArrowFunctionExpression2.ts: -------------------------------------------------------------------------------- 1 | a = () => { } || a -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/ArrowFunctionExpressions/parserArrowFunctionExpression3.ts: -------------------------------------------------------------------------------- 1 | a = (() => { } || a) -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/ArrowFunctionExpressions/parserArrowFunctionExpression4.ts: -------------------------------------------------------------------------------- 1 | a = (() => { }, a) -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/ClassDeclarations/parserClassDeclaration1.ts: -------------------------------------------------------------------------------- 1 | class C extends A extends B { 2 | } -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/EnumDeclarations/parserEnumDeclaration3.ts: -------------------------------------------------------------------------------- 1 | declare enum E { 2 | A = 1 3 | } -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/ErrorRecovery/ArrowFunctions/ArrowFunction3.ts: -------------------------------------------------------------------------------- 1 | var v = (a): => { 2 | 3 | }; -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/ErrorRecovery/parserErrantEqualsGreaterThanAfterFunction1.ts: -------------------------------------------------------------------------------- 1 | function f() => 4; -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/Generics/parserGenericConstraint4.ts: -------------------------------------------------------------------------------- 1 | class C > > { 2 | } -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/Generics/parserGenericConstraint5.ts: -------------------------------------------------------------------------------- 1 | class C> > { 2 | } -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/Generics/parserGenericConstraint6.ts: -------------------------------------------------------------------------------- 1 | class C >> { 2 | } -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/Generics/parserGenericConstraint7.ts: -------------------------------------------------------------------------------- 1 | class C>> { 2 | } -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/Generics/parserMemberAccessOffOfGenericType1.ts: -------------------------------------------------------------------------------- 1 | var v = List.makeChild(); -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/IndexSignatures/parserIndexSignature2.ts: -------------------------------------------------------------------------------- 1 | interface I { 2 | [public a] 3 | } -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/IndexSignatures/parserIndexSignature6.ts: -------------------------------------------------------------------------------- 1 | interface I { 2 | [a:boolean] 3 | } -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/IndexSignatures/parserIndexSignature7.ts: -------------------------------------------------------------------------------- 1 | interface I { 2 | [a:string] 3 | } -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/IndexSignatures/parserIndexSignature9.ts: -------------------------------------------------------------------------------- 1 | interface I { 2 | []: number 3 | } -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/InterfaceDeclarations/parserInterfaceDeclaration3.ts: -------------------------------------------------------------------------------- 1 | public interface I { 2 | } -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/InterfaceDeclarations/parserInterfaceDeclaration4.ts: -------------------------------------------------------------------------------- 1 | static interface I { 2 | } -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/InterfaceDeclarations/parserInterfaceDeclaration5.ts: -------------------------------------------------------------------------------- 1 | declare interface I { 2 | } -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/InterfaceDeclarations/parserInterfaceDeclaration7.ts: -------------------------------------------------------------------------------- 1 | export interface I { 2 | } -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/InterfaceDeclarations/parserInterfaceDeclaration8.ts: -------------------------------------------------------------------------------- 1 | interface string { 2 | } -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/MethodSignatures/parserMethodSignature10.ts: -------------------------------------------------------------------------------- 1 | interface I { 2 | 1?(); 3 | } -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/MethodSignatures/parserMethodSignature11.ts: -------------------------------------------------------------------------------- 1 | interface I { 2 | 2(); 3 | } -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/MethodSignatures/parserMethodSignature12.ts: -------------------------------------------------------------------------------- 1 | interface I { 2 | 3?(); 3 | } -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/MethodSignatures/parserMethodSignature3.ts: -------------------------------------------------------------------------------- 1 | interface I { 2 | C(); 3 | } -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/MethodSignatures/parserMethodSignature4.ts: -------------------------------------------------------------------------------- 1 | interface I { 2 | D?(); 3 | } -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/MethodSignatures/parserMethodSignature5.ts: -------------------------------------------------------------------------------- 1 | interface I { 2 | "E"(); 3 | } -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/MethodSignatures/parserMethodSignature6.ts: -------------------------------------------------------------------------------- 1 | interface I { 2 | "F"?(); 3 | } -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/MethodSignatures/parserMethodSignature7.ts: -------------------------------------------------------------------------------- 1 | interface I { 2 | "G"(); 3 | } -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/MethodSignatures/parserMethodSignature8.ts: -------------------------------------------------------------------------------- 1 | interface I { 2 | "H"?(); 3 | } -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/ParameterLists/parserParameterList1.ts: -------------------------------------------------------------------------------- 1 | class C { 2 | F(...A, B) { } 3 | } -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/ParameterLists/parserParameterList5.ts: -------------------------------------------------------------------------------- 1 | function A(): (public B) => C { 2 | } -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/ParameterLists/parserParameterList9.ts: -------------------------------------------------------------------------------- 1 | class C { 2 | foo(...bar?) { } 3 | } -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/PropertyAssignments/parserFunctionPropertyAssignment1.ts: -------------------------------------------------------------------------------- 1 | var v = { foo() { } }; -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/PropertyAssignments/parserFunctionPropertyAssignment2.ts: -------------------------------------------------------------------------------- 1 | var v = { 0() { } }; -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/PropertyAssignments/parserFunctionPropertyAssignment3.ts: -------------------------------------------------------------------------------- 1 | var v = { "foo"() { } }; -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/PropertyAssignments/parserFunctionPropertyAssignment4.ts: -------------------------------------------------------------------------------- 1 | var v = { 0() { } }; -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/PropertySignatures/parserPropertySignature1.ts: -------------------------------------------------------------------------------- 1 | interface I { 2 | A; 3 | } -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/PropertySignatures/parserPropertySignature10.ts: -------------------------------------------------------------------------------- 1 | interface I { 2 | 1?; 3 | } -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/PropertySignatures/parserPropertySignature2.ts: -------------------------------------------------------------------------------- 1 | interface I { 2 | B?; 3 | } -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/PropertySignatures/parserPropertySignature3.ts: -------------------------------------------------------------------------------- 1 | interface I { 2 | C:any; 3 | } -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/PropertySignatures/parserPropertySignature5.ts: -------------------------------------------------------------------------------- 1 | interface I { 2 | "E"; 3 | } -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/PropertySignatures/parserPropertySignature6.ts: -------------------------------------------------------------------------------- 1 | interface I { 2 | "F"?; 3 | } -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/PropertySignatures/parserPropertySignature9.ts: -------------------------------------------------------------------------------- 1 | interface I { 2 | 0; 3 | } -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/Protected/Protected9.ts: -------------------------------------------------------------------------------- 1 | class C { 2 | constructor(protected p) { } 3 | } -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/RegressionTests/parserTernaryAndCommaOperators1.ts: -------------------------------------------------------------------------------- 1 | b.src ? 1 : 2, c && d; 2 | -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/RegularExpressions/parserRegularExpression2.ts: -------------------------------------------------------------------------------- 1 | href.match(/:\/\/(.[^/]+)/)[1]; -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/RegularExpressions/parserRegularExpressionDivideAmbiguity4.ts: -------------------------------------------------------------------------------- 1 | foo(/notregexp); -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/SkippedTokens/parserSkippedTokens10.ts: -------------------------------------------------------------------------------- 1 | \ 2 | \ 3 | /*existing trivia*/ ; 4 | -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/SkippedTokens/parserSkippedTokens15.ts: -------------------------------------------------------------------------------- 1 | /*existing trivia*/ 2 | \ 3 | \ 4 | ; -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/SkippedTokens/parserSkippedTokens9.ts: -------------------------------------------------------------------------------- 1 | ; // existing trivia 2 | /*foo*/ \ /*bar*/ -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/Statements/BreakStatements/parser_breakNotInIterationOrSwitchStatement1.ts: -------------------------------------------------------------------------------- 1 | break; -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/Statements/BreakStatements/parser_breakTarget1.ts: -------------------------------------------------------------------------------- 1 | target: 2 | break target; -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/Statements/ReturnStatements/parserReturnStatement2.ts: -------------------------------------------------------------------------------- 1 | { 2 | return; 3 | } -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/StrictMode/parserStrictMode1.ts: -------------------------------------------------------------------------------- 1 | foo1(); 2 | foo1(); 3 | foo1(); 4 | static(); -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/StrictMode/parserStrictMode10.ts: -------------------------------------------------------------------------------- 1 | "use strict"; 2 | function f(eval) { 3 | } -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/StrictMode/parserStrictMode12.ts: -------------------------------------------------------------------------------- 1 | "use strict"; 2 | var v = { set foo(eval) { } } -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/parserImportDeclaration1.ts: -------------------------------------------------------------------------------- 1 | import TypeScript = TypeScriptServices.TypeScript; -------------------------------------------------------------------------------- /tests/cases/conformance/scanner/ecmascript5/scannerImportDeclaration1.ts: -------------------------------------------------------------------------------- 1 | import TypeScript = TypeScriptServices.TypeScript; -------------------------------------------------------------------------------- /tests/cases/conformance/types/primitives/boolean/boolInsteadOfBoolean.ts: -------------------------------------------------------------------------------- 1 | var x: bool; 2 | var a: boolean = x; 3 | x = a; -------------------------------------------------------------------------------- /tests/cases/conformance/types/primitives/undefined/directReferenceToUndefined.ts: -------------------------------------------------------------------------------- 1 | var x: Undefined; 2 | var y = undefined; -------------------------------------------------------------------------------- /tests/cases/fourslash/todoComments3.ts: -------------------------------------------------------------------------------- 1 | //// // [|TODO with stuff|] 2 | 3 | verify.todoCommentsInCurrentFile(["TODO"]); -------------------------------------------------------------------------------- /tests/cases/fourslash_old/todoComments1.ts: -------------------------------------------------------------------------------- 1 | //// // [|TODO|] 2 | debugger; 3 | verify.todoCommentsInCurrentFile(["TODO"]); -------------------------------------------------------------------------------- /tests/cases/fourslash_old/todoComments13.ts: -------------------------------------------------------------------------------- 1 | //// TODO 2 | 3 | debugger; 4 | verify.todoCommentsInCurrentFile(["TODO"]); -------------------------------------------------------------------------------- /tests/cases/fourslash_old/todoComments2.ts: -------------------------------------------------------------------------------- 1 | //// // not TODO 2 | debugger; 3 | verify.todoCommentsInCurrentFile(["TODO"]); -------------------------------------------------------------------------------- /tests/cases/unittests/services/formatting/testCode/formatting/implicitModuleBaseline.ts: -------------------------------------------------------------------------------- 1 | export class A { 2 | 3 | } 4 | -------------------------------------------------------------------------------- /tests/cases/unittests/services/formatting/testCode/testCode/formatting/onSemiColonBaseline.ts: -------------------------------------------------------------------------------- 1 | var a = b + c ^ d - e * ++f; -------------------------------------------------------------------------------- /tests/baselines/reference/bom-utf8.js: -------------------------------------------------------------------------------- 1 | //// [bom-utf8.ts] 2 | var x=10; 3 | 4 | 5 | //// [bom-utf8.js] 6 | var x = 10; 7 | -------------------------------------------------------------------------------- /tests/baselines/reference/bom-utf8.types: -------------------------------------------------------------------------------- 1 | === tests/cases/compiler/bom-utf8.ts === 2 | var x=10; 3 | >x : number 4 | 5 | -------------------------------------------------------------------------------- /tests/baselines/reference/emptyFile.types: -------------------------------------------------------------------------------- 1 | === tests/cases/compiler/emptyFile.ts === 2 | 3 | No type information for this code. -------------------------------------------------------------------------------- /tests/baselines/reference/project/sourcemapModuleMultifolderSpecifyOutputFile/amd/bin/test.js: -------------------------------------------------------------------------------- 1 | //# sourceMappingURL=test.js.map -------------------------------------------------------------------------------- /tests/baselines/reference/project/sourcemapModuleMultifolderSpecifyOutputFile/node/bin/test.js: -------------------------------------------------------------------------------- 1 | //# sourceMappingURL=test.js.map -------------------------------------------------------------------------------- /tests/baselines/reference/project/sourcemapModuleSubfolderSpecifyOutputFile/node/bin/test.js: -------------------------------------------------------------------------------- 1 | //# sourceMappingURL=test.js.map -------------------------------------------------------------------------------- /tests/baselines/reference/project/sourcerootUrlModuleSimpleSpecifyOutputFile/amd/bin/test.js: -------------------------------------------------------------------------------- 1 | //# sourceMappingURL=test.js.map -------------------------------------------------------------------------------- /tests/baselines/reference/project/sourcerootUrlModuleSimpleSpecifyOutputFile/node/bin/test.js: -------------------------------------------------------------------------------- 1 | //# sourceMappingURL=test.js.map -------------------------------------------------------------------------------- /tests/baselines/reference/project/sourcerootUrlModuleSubfolderSpecifyOutputFile/amd/bin/test.js: -------------------------------------------------------------------------------- 1 | //# sourceMappingURL=test.js.map -------------------------------------------------------------------------------- /tests/baselines/reference/project/sourcerootUrlModuleSubfolderSpecifyOutputFile/node/bin/test.js: -------------------------------------------------------------------------------- 1 | //# sourceMappingURL=test.js.map -------------------------------------------------------------------------------- /tests/baselines/reference/separate1-1.js: -------------------------------------------------------------------------------- 1 | //// [separate1-1.ts] 2 | X.f(); 3 | 4 | //// [separate1-1.js] 5 | X.f(); 6 | -------------------------------------------------------------------------------- /tests/cases/compiler/ambientEnumElementInitializer6.ts: -------------------------------------------------------------------------------- 1 | declare module M { 2 | enum E { 3 | e = 3 4 | } 5 | } -------------------------------------------------------------------------------- /tests/cases/compiler/cannotInvokeNewOnErrorExpression.ts: -------------------------------------------------------------------------------- 1 | module M 2 | { 3 | class ClassA {} 4 | } 5 | var t = new M.ClassA[]; -------------------------------------------------------------------------------- /tests/cases/compiler/collisionCodeGenEnumWithEnumMemberConflict.ts: -------------------------------------------------------------------------------- 1 | enum Color { 2 | Color, 3 | Thing = Color 4 | } -------------------------------------------------------------------------------- /tests/cases/compiler/commentOnStaticMember1.ts: -------------------------------------------------------------------------------- 1 | class Greeter { 2 | //Hello World 3 | static foo(){ 4 | } 5 | } -------------------------------------------------------------------------------- /tests/cases/compiler/contextualTyping23.ts: -------------------------------------------------------------------------------- 1 | var foo:(a:{():number; (i:number):number; })=>number; foo = function(a){return 5}; -------------------------------------------------------------------------------- /tests/cases/compiler/contextuallyTypingOrOperator3.ts: -------------------------------------------------------------------------------- 1 | function foo(u: U) { 2 | var x3: U = u || u; 3 | } -------------------------------------------------------------------------------- /tests/cases/compiler/continueNotInIterationStatement2.ts: -------------------------------------------------------------------------------- 1 | while (true) { 2 | function f() { 3 | continue; 4 | } 5 | } -------------------------------------------------------------------------------- /tests/cases/compiler/declFileForVarList.ts: -------------------------------------------------------------------------------- 1 | // @declaration: true 2 | 3 | var x, y, z = 1; 4 | var x1 = 1, y2 = 2, z2 = 3; -------------------------------------------------------------------------------- /tests/cases/compiler/declFileOptionalInterfaceMethod.ts: -------------------------------------------------------------------------------- 1 | // @declaration: true 2 | interface X { 3 | f? (); 4 | } 5 | -------------------------------------------------------------------------------- /tests/cases/compiler/duplicateConstructSignature2.ts: -------------------------------------------------------------------------------- 1 | interface I { 2 | (x: T): number; 3 | (x: T): string; 4 | } -------------------------------------------------------------------------------- /tests/cases/compiler/exportAssignmentWithExports.ts: -------------------------------------------------------------------------------- 1 | //@module: commonjs 2 | export class C { } 3 | class D { } 4 | export = D; -------------------------------------------------------------------------------- /tests/cases/compiler/functionAssignmentError.ts: -------------------------------------------------------------------------------- 1 | var func = function (){return "ONE";}; 2 | func = function (){return "ONE";}; -------------------------------------------------------------------------------- /tests/cases/compiler/functionOverloads17.ts: -------------------------------------------------------------------------------- 1 | function foo():{a:number;} 2 | function foo():{a:string;} { return {a:""} } 3 | -------------------------------------------------------------------------------- /tests/cases/compiler/functionReturningItself.ts: -------------------------------------------------------------------------------- 1 | // @declaration: true 2 | function somefn() { 3 | return somefn; 4 | } -------------------------------------------------------------------------------- /tests/cases/compiler/genericTypeUsedWithoutTypeArguments3.ts: -------------------------------------------------------------------------------- 1 | interface Foo { } 2 | interface Bar extends Foo { } 3 | -------------------------------------------------------------------------------- /tests/cases/compiler/i3.ts: -------------------------------------------------------------------------------- 1 | interface I3 { one?: number; }; 2 | var x: {one: number}; 3 | var i: I3; 4 | 5 | i = x; 6 | x = i; -------------------------------------------------------------------------------- /tests/cases/compiler/interface0.ts: -------------------------------------------------------------------------------- 1 | interface Generic { 2 | x: T; 3 | } 4 | 5 | var y: Generic = { x: 3 }; 6 | -------------------------------------------------------------------------------- /tests/cases/compiler/interfaceWithOptionalProperty.ts: -------------------------------------------------------------------------------- 1 | // @declaration: true 2 | 3 | interface I { 4 | x?: number; 5 | } -------------------------------------------------------------------------------- /tests/cases/compiler/mergedEnumDeclarationCodeGen.ts: -------------------------------------------------------------------------------- 1 | enum E { 2 | a, 3 | b = a 4 | } 5 | enum E { 6 | c = a 7 | } -------------------------------------------------------------------------------- /tests/cases/compiler/moduleKeywordRepeatError.ts: -------------------------------------------------------------------------------- 1 | // "module.module { }" should raise a syntax error 2 | 3 | module.module { } -------------------------------------------------------------------------------- /tests/cases/compiler/nestedIndexer.ts: -------------------------------------------------------------------------------- 1 | function then(x) { 2 | 3 | var match: { [index: number]: string; } 4 | 5 | } 6 | -------------------------------------------------------------------------------- /tests/cases/compiler/noSelfOnVars.ts: -------------------------------------------------------------------------------- 1 | function foo() { 2 | function bar() { } 3 | var x = bar; 4 | } 5 | 6 | 7 | -------------------------------------------------------------------------------- /tests/cases/compiler/recursiveBaseCheck3.ts: -------------------------------------------------------------------------------- 1 | class A extends C { } 2 | class C extends A { } 3 | 4 | (new C).blah; -------------------------------------------------------------------------------- /tests/cases/compiler/recursiveGetterAccess.ts: -------------------------------------------------------------------------------- 1 | class MyClass { 2 | get testProp() { return this.testProp; } 3 | } 4 | 5 | -------------------------------------------------------------------------------- /tests/cases/compiler/staticMethodsReferencingClassTypeParameters.ts: -------------------------------------------------------------------------------- 1 | class C { 2 | static s(p: T) { return p; } 3 | } -------------------------------------------------------------------------------- /tests/cases/compiler/stringLiteralPropertyNameWithLineContinuation1.ts: -------------------------------------------------------------------------------- 1 | var x = {'text\ 2 | ':'hello'} 3 | x.text = "bar" 4 | -------------------------------------------------------------------------------- /tests/cases/compiler/thisInConstructorParameter1.ts: -------------------------------------------------------------------------------- 1 | class Foo { 2 | public y; 3 | constructor(x = this.y) { } 4 | } -------------------------------------------------------------------------------- /tests/cases/compiler/toStringOnPrimitives.ts: -------------------------------------------------------------------------------- 1 | true.toString() 2 | var aBool = false; 3 | aBool.toString(); 4 | 1..toString(); -------------------------------------------------------------------------------- /tests/cases/compiler/typeVal.ts: -------------------------------------------------------------------------------- 1 | interface I { 2 | I:number; 3 | } 4 | 5 | var I:I = { I: 3}; 6 | I.I=4; 7 | 8 | -------------------------------------------------------------------------------- /tests/cases/conformance/ambient/ambientExternalModuleInsideNonAmbient.ts: -------------------------------------------------------------------------------- 1 | module M { 2 | export declare module "M" { } 3 | } -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/Accessors/parserAccessors7.ts: -------------------------------------------------------------------------------- 1 | // @target: es5 2 | var v = { get foo(v: number) { } }; -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/ArrayLiteralExpressions/parserArrayLiteralExpression14.ts: -------------------------------------------------------------------------------- 1 | var v = [,,1,1,,1,,1,1,,1]; -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/ArrayLiteralExpressions/parserArrayLiteralExpression15.ts: -------------------------------------------------------------------------------- 1 | var v = [,,1,1,,1,,1,1,,1,]; -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/ClassDeclarations/parserClassDeclaration3.ts: -------------------------------------------------------------------------------- 1 | class C implements A extends B { 2 | } -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/ClassDeclarations/parserClassDeclaration8.ts: -------------------------------------------------------------------------------- 1 | class C { 2 | constructor(); 3 | } -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/EnumDeclarations/parserEnumDeclaration1.ts: -------------------------------------------------------------------------------- 1 | enum E { 2 | Foo = 1, 3 | Bar 4 | } -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/ErrorRecovery/ArrowFunctions/ArrowFunction1.ts: -------------------------------------------------------------------------------- 1 | var v = (a: ) => { 2 | 3 | }; -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/ErrorRecovery/ArrowFunctions/ArrowFunction2.ts: -------------------------------------------------------------------------------- 1 | var v = (a: b,) => { 2 | 3 | }; -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/ErrorRecovery/ArrowFunctions/ArrowFunction4.ts: -------------------------------------------------------------------------------- 1 | var v = (a, b) => { 2 | 3 | }; -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/ErrorRecovery/ParameterLists/parserErrorRecovery_ParameterList5.ts: -------------------------------------------------------------------------------- 1 | (a:number => { } -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/ErrorRecovery/TypeArgumentLists/parserX_TypeArgumentList1.ts: -------------------------------------------------------------------------------- 1 | Foo(4, 5, 6); -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/ErrorRecovery/VariableLists/parserErrorRecovery_VariableList1.ts: -------------------------------------------------------------------------------- 1 | var a, 2 | return; -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/ErrorRecovery/VariableLists/parserVariableStatement1.ts: -------------------------------------------------------------------------------- 1 | var a, 2 | b, 3 | c -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/ErrorRecovery/VariableLists/parserVariableStatement2.ts: -------------------------------------------------------------------------------- 1 | var a 2 | , b 3 | , c -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/ErrorRecovery/parserCommaInTypeMemberList1.ts: -------------------------------------------------------------------------------- 1 | var v: { workItem: any, width: string }; -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/ErrorRecovery/parserErrantEqualsGreaterThanAfterFunction2.ts: -------------------------------------------------------------------------------- 1 | function f(p: A) => p; -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/ExportAssignments/parserExportAssignment5.ts: -------------------------------------------------------------------------------- 1 | module M { 2 | export = A; 3 | } -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/FunctionDeclarations/parserFunctionDeclaration2.ts: -------------------------------------------------------------------------------- 1 | declare function Foo() { 2 | } -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/Generics/parserObjectCreation1.ts: -------------------------------------------------------------------------------- 1 | var autoToken: number[] = new Array(1); -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/IndexSignatures/parserIndexSignature10.ts: -------------------------------------------------------------------------------- 1 | interface I { 2 | [a, b]: number 3 | } -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/InterfaceDeclarations/parserInterfaceDeclaration2.ts: -------------------------------------------------------------------------------- 1 | interface I implements A { 2 | } -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/ParameterLists/parserParameterList10.ts: -------------------------------------------------------------------------------- 1 | class C { 2 | foo(...bar = 0) { } 3 | } -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/ParameterLists/parserParameterList13.ts: -------------------------------------------------------------------------------- 1 | interface I { 2 | new (public x); 3 | } -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/PropertySignatures/parserPropertySignature11.ts: -------------------------------------------------------------------------------- 1 | interface I { 2 | 2:any; 3 | } -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/PropertySignatures/parserPropertySignature12.ts: -------------------------------------------------------------------------------- 1 | interface I { 2 | 3?:any; 3 | } -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/PropertySignatures/parserPropertySignature4.ts: -------------------------------------------------------------------------------- 1 | interface I { 2 | D?:any; 3 | } -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/PropertySignatures/parserPropertySignature7.ts: -------------------------------------------------------------------------------- 1 | interface I { 2 | "G":any; 3 | } -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/PropertySignatures/parserPropertySignature8.ts: -------------------------------------------------------------------------------- 1 | interface I { 2 | "H"?:any; 3 | } -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/RegressionTests/parser509546.ts: -------------------------------------------------------------------------------- 1 | export class Logger { 2 | public 3 | } 4 | -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/RegressionTests/parser509546_1.ts: -------------------------------------------------------------------------------- 1 | export class Logger { 2 | public 3 | } 4 | -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/RegressionTests/parser509669.ts: -------------------------------------------------------------------------------- 1 | function foo():any { 2 | return ():void {}; 3 | } -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/RegressionTests/parser643728.ts: -------------------------------------------------------------------------------- 1 | interface C { 2 | foo; 3 | new; 4 | } 5 | -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/RegularExpressions/parserRegularExpressionDivideAmbiguity2.ts: -------------------------------------------------------------------------------- 1 | (1) /notregexp/a.foo(); -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/RegularExpressions/parserRegularExpressionDivideAmbiguity3.ts: -------------------------------------------------------------------------------- 1 | if (1) /regexp/a.foo(); -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/SkippedTokens/parserSkippedTokens14.ts: -------------------------------------------------------------------------------- 1 | \ 2 | /*existing trivia*/ 3 | \ 4 | ; 5 | -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/Statements/ContinueStatements/parser_continueNotInIterationStatement1.ts: -------------------------------------------------------------------------------- 1 | continue; -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/StrictMode/parserStrictMode11.ts: -------------------------------------------------------------------------------- 1 | "use strict"; 2 | var v = function f(eval) { 3 | }; -------------------------------------------------------------------------------- /tests/cases/conformance/parser/ecmascript5/StrictMode/parserStrictMode9.ts: -------------------------------------------------------------------------------- 1 | "use strict"; 2 | var v = function eval() { 3 | }; -------------------------------------------------------------------------------- /tests/cases/conformance/types/typeRelationships/assignmentCompatibility/assignmentCompatWithWithGenericConstructSignatures.ts: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /tests/cases/fourslash/todoComments15.ts: -------------------------------------------------------------------------------- 1 | //// "// HACK 1"; 2 | 3 | verify.todoCommentsInCurrentFile(["TODO(jason)", "HACK"]); -------------------------------------------------------------------------------- /tests/cases/fourslash_old/todoComments14.ts: -------------------------------------------------------------------------------- 1 | //// BAR // [|TODO|] 2 | debugger; 3 | verify.todoCommentsInCurrentFile(["TODO"]); -------------------------------------------------------------------------------- /tests/cases/fourslash_old/todoComments4.ts: -------------------------------------------------------------------------------- 1 | //// // TODOnomatch 2 | debugger; 3 | verify.todoCommentsInCurrentFile(["TODO"]); -------------------------------------------------------------------------------- /tests/cases/projects/ModuleIdentifier/consume.ts: -------------------------------------------------------------------------------- 1 | import M = require("./decl"); 2 | 3 | var p : M.P; 4 | var x1 = M.a; 5 | -------------------------------------------------------------------------------- /tests/cases/projects/No-default-lib/test.ts: -------------------------------------------------------------------------------- 1 | /// 2 | 3 | var x: Array; 4 | 5 | -------------------------------------------------------------------------------- /tests/cases/projects/RelativePaths/A/a.ts: -------------------------------------------------------------------------------- 1 | import b = require('b'); 2 | 3 | export function A(): void { 4 | b.B(); 5 | } -------------------------------------------------------------------------------- /tests/cases/projects/RelativePaths/A/b.ts: -------------------------------------------------------------------------------- 1 | export function B(): void { 2 | throw new Error('Should not be called'); 3 | } -------------------------------------------------------------------------------- /tests/cases/projects/privacyCheck-IndirectReference/test.ts: -------------------------------------------------------------------------------- 1 | import im1 = require("externalModule"); 2 | export var x = im1.x; -------------------------------------------------------------------------------- /tests/cases/unittests/services/formatting/testCode/formatting/spaceAfterConstructorBaseline.ts: -------------------------------------------------------------------------------- 1 | class test { constructor() { } } -------------------------------------------------------------------------------- /tests/baselines/reference/TupleType1.js: -------------------------------------------------------------------------------- 1 | //// [TupleType1.ts] 2 | var v: [number] 3 | 4 | //// [TupleType1.js] 5 | var v; 6 | -------------------------------------------------------------------------------- /tests/baselines/reference/bom-utf16be.types: -------------------------------------------------------------------------------- 1 | === tests/cases/compiler/bom-utf16be.ts === 2 | var x=10; 3 | >x : number 4 | 5 | -------------------------------------------------------------------------------- /tests/baselines/reference/bom-utf16le.types: -------------------------------------------------------------------------------- 1 | === tests/cases/compiler/bom-utf16le.ts === 2 | var x=10; 3 | >x : number 4 | 5 | -------------------------------------------------------------------------------- /tests/baselines/reference/nullKeyword.js: -------------------------------------------------------------------------------- 1 | //// [nullKeyword.ts] 2 | null.foo; 3 | 4 | //// [nullKeyword.js] 5 | null.foo; 6 | -------------------------------------------------------------------------------- /tests/baselines/reference/project/sourceRootAbsolutePathModuleSimpleSpecifyOutputFile/amd/bin/test.js: -------------------------------------------------------------------------------- 1 | //# sourceMappingURL=test.js.map -------------------------------------------------------------------------------- /tests/baselines/reference/project/sourceRootRelativePathModuleSimpleSpecifyOutputFile/amd/bin/test.js: -------------------------------------------------------------------------------- 1 | //# sourceMappingURL=test.js.map -------------------------------------------------------------------------------- /tests/baselines/reference/project/sourcerootUrlModuleMultifolderSpecifyOutputFile/amd/bin/test.js: -------------------------------------------------------------------------------- 1 | //# sourceMappingURL=test.js.map -------------------------------------------------------------------------------- /tests/baselines/reference/project/sourcerootUrlModuleMultifolderSpecifyOutputFile/node/bin/test.js: -------------------------------------------------------------------------------- 1 | //# sourceMappingURL=test.js.map -------------------------------------------------------------------------------- /tests/cases/compiler/badOverloadError.ts: -------------------------------------------------------------------------------- 1 | function method() { 2 | var dictionary = <{ [index: string]: string; }>{}; 3 | } 4 | --------------------------------------------------------------------------------