Datasets:

---

Anonymous2023

/

dataset2js

like 0

[ "function", "isSymbolAccessible", "(", "symbol", ",", "enclosingDeclaration", ",", "meaning", ",", "shouldComputeAliasesToMakeVisible", ")", "{", "if", "(", "symbol", "&&", "enclosingDeclaration", "&&", "!", "(", "symbol", ".", "flags", "&", "262144", ")", ")", "{", "var", "initialSymbol", "=", "symbol", ";", "var", "meaningToLook", "=", "meaning", ";", "while", "(", "symbol", ")", "{", "var", "accessibleSymbolChain", "=", "getAccessibleSymbolChain", "(", "symbol", ",", "enclosingDeclaration", ",", "meaningToLook", ",", "false", ")", ";", "if", "(", "accessibleSymbolChain", ")", "{", "var", "hasAccessibleDeclarations", "=", "hasVisibleDeclarations", "(", "accessibleSymbolChain", "[", "0", "]", ",", "shouldComputeAliasesToMakeVisible", ")", ";", "if", "(", "!", "hasAccessibleDeclarations", ")", "{", "return", "{", "accessibility", ":", "1", ",", "errorSymbolName", ":", "symbolToString", "(", "initialSymbol", ",", "enclosingDeclaration", ",", "meaning", ")", ",", "errorModuleName", ":", "symbol", "!==", "initialSymbol", "?", "symbolToString", "(", "symbol", ",", "enclosingDeclaration", ",", "1920", ")", ":", "undefined", "}", ";", "}", "return", "hasAccessibleDeclarations", ";", "}", "meaningToLook", "=", "getQualifiedLeftMeaning", "(", "meaning", ")", ";", "symbol", "=", "getParentOfSymbol", "(", "symbol", ")", ";", "}", "var", "symbolExternalModule", "=", "ts", ".", "forEach", "(", "initialSymbol", ".", "declarations", ",", "getExternalModuleContainer", ")", ";", "if", "(", "symbolExternalModule", ")", "{", "var", "enclosingExternalModule", "=", "getExternalModuleContainer", "(", "enclosingDeclaration", ")", ";", "if", "(", "symbolExternalModule", "!==", "enclosingExternalModule", ")", "{", "return", "{", "accessibility", ":", "2", ",", "errorSymbolName", ":", "symbolToString", "(", "initialSymbol", ",", "enclosingDeclaration", ",", "meaning", ")", ",", "errorModuleName", ":", "symbolToString", "(", "symbolExternalModule", ")", "}", ";", "}", "}", "return", "{", "accessibility", ":", "1", ",", "errorSymbolName", ":", "symbolToString", "(", "initialSymbol", ",", "enclosingDeclaration", ",", "meaning", ")", "}", ";", "}", "return", "{", "accessibility", ":", "0", "}", ";", "function", "getExternalModuleContainer", "(", "declaration", ")", "{", "for", "(", ";", "declaration", ";", "declaration", "=", "declaration", ".", "parent", ")", "{", "if", "(", "hasExternalModuleSymbol", "(", "declaration", ")", ")", "{", "return", "getSymbolOfNode", "(", "declaration", ")", ";", "}", "}", "}", "}" ]

[ "Check", "if", "the", "given", "symbol", "in", "given", "enclosing", "declaration", "is", "accessible", "and", "mark", "all", "associated", "alias", "to", "be", "visible", "if", "requested" ]

[ "function", "appendPropertyOrElementAccessForSymbol", "(", "symbol", ",", "writer", ")", "{", "var", "symbolName", "=", "getNameOfSymbol", "(", "symbol", ")", ";", "var", "firstChar", "=", "symbolName", ".", "charCodeAt", "(", "0", ")", ";", "var", "needsElementAccess", "=", "!", "ts", ".", "isIdentifierStart", "(", "firstChar", ",", "languageVersion", ")", ";", "if", "(", "needsElementAccess", ")", "{", "writePunctuation", "(", "writer", ",", "19", ")", ";", "if", "(", "ts", ".", "isSingleOrDoubleQuote", "(", "firstChar", ")", ")", "{", "writer", ".", "writeStringLiteral", "(", "symbolName", ")", ";", "}", "else", "{", "writer", ".", "writeSymbol", "(", "symbolName", ",", "symbol", ")", ";", "}", "writePunctuation", "(", "writer", ",", "20", ")", ";", "}", "else", "{", "writePunctuation", "(", "writer", ",", "21", ")", ";", "writer", ".", "writeSymbol", "(", "symbolName", ",", "symbol", ")", ";", "}", "}" ]

[ "Writes", "a", "property", "access", "or", "element", "access", "with", "the", "name", "of", "the", "symbol", "out", "to", "the", "writer", ".", "Uses", "the", "original", "source", "text", "for", "the", "name", "of", "the", "symbol", "if", "it", "is", "available", "to", "match", "how", "the", "user", "wrote", "the", "name", "ensuring", "that", "any", "names", "written", "with", "literals", "use", "element", "accesses", "." ]

[ "function", "buildSymbolDisplay", "(", "symbol", ",", "writer", ",", "enclosingDeclaration", ",", "meaning", ",", "flags", ",", "typeFlags", ")", "{", "var", "parentSymbol", ";", "function", "appendParentTypeArgumentsAndSymbolName", "(", "symbol", ")", "{", "if", "(", "parentSymbol", ")", "{", "if", "(", "flags", "&", "1", ")", "{", "if", "(", "symbol", ".", "flags", "&", "16777216", ")", "{", "buildDisplayForTypeArgumentsAndDelimiters", "(", "getTypeParametersOfClassOrInterface", "(", "parentSymbol", ")", ",", "symbol", ".", "mapper", ",", "writer", ",", "enclosingDeclaration", ")", ";", "}", "else", "{", "buildTypeParameterDisplayFromSymbol", "(", "parentSymbol", ",", "writer", ",", "enclosingDeclaration", ")", ";", "}", "}", "appendPropertyOrElementAccessForSymbol", "(", "symbol", ",", "writer", ")", ";", "}", "else", "{", "appendSymbolNameOnly", "(", "symbol", ",", "writer", ")", ";", "}", "parentSymbol", "=", "symbol", ";", "}", "writer", ".", "trackSymbol", "(", "symbol", ",", "enclosingDeclaration", ",", "meaning", ")", ";", "function", "walkSymbol", "(", "symbol", ",", "meaning", ")", "{", "if", "(", "symbol", ")", "{", "var", "accessibleSymbolChain", "=", "getAccessibleSymbolChain", "(", "symbol", ",", "enclosingDeclaration", ",", "meaning", ",", "!", "!", "(", "flags", "&", "2", ")", ")", ";", "if", "(", "!", "accessibleSymbolChain", "||", "needsQualification", "(", "accessibleSymbolChain", "[", "0", "]", ",", "enclosingDeclaration", ",", "accessibleSymbolChain", ".", "length", "===", "1", "?", "meaning", ":", "getQualifiedLeftMeaning", "(", "meaning", ")", ")", ")", "{", "walkSymbol", "(", "getParentOfSymbol", "(", "accessibleSymbolChain", "?", "accessibleSymbolChain", "[", "0", "]", ":", "symbol", ")", ",", "getQualifiedLeftMeaning", "(", "meaning", ")", ")", ";", "}", "if", "(", "accessibleSymbolChain", ")", "{", "for", "(", "var", "_i", "=", "0", ",", "accessibleSymbolChain_1", "=", "accessibleSymbolChain", ";", "_i", "<", "accessibleSymbolChain_1", ".", "length", ";", "_i", "++", ")", "{", "var", "accessibleSymbol", "=", "accessibleSymbolChain_1", "[", "_i", "]", ";", "appendParentTypeArgumentsAndSymbolName", "(", "accessibleSymbol", ")", ";", "}", "}", "else", "{", "if", "(", "!", "parentSymbol", "&&", "ts", ".", "forEach", "(", "symbol", ".", "declarations", ",", "hasExternalModuleSymbol", ")", ")", "{", "return", ";", "}", "if", "(", "symbol", ".", "flags", "&", "2048", "||", "symbol", ".", "flags", "&", "4096", ")", "{", "return", ";", "}", "appendParentTypeArgumentsAndSymbolName", "(", "symbol", ")", ";", "}", "}", "}", "var", "isTypeParameter", "=", "symbol", ".", "flags", "&", "262144", ";", "var", "typeFormatFlag", "=", "128", "&", "typeFlags", ";", "if", "(", "!", "isTypeParameter", "&&", "(", "enclosingDeclaration", "||", "typeFormatFlag", ")", ")", "{", "walkSymbol", "(", "symbol", ",", "meaning", ")", ";", "return", ";", "}", "return", "appendParentTypeArgumentsAndSymbolName", "(", "symbol", ")", ";", "}" ]

[ "Enclosing", "declaration", "is", "optional", "when", "we", "don", "t", "want", "to", "get", "qualified", "name", "in", "the", "enclosing", "declaration", "scope", "Meaning", "needs", "to", "be", "specified", "if", "the", "enclosing", "declaration", "is", "given" ]

[ "function", "pushTypeResolution", "(", "target", ",", "propertyName", ")", "{", "var", "resolutionCycleStartIndex", "=", "findResolutionCycleStartIndex", "(", "target", ",", "propertyName", ")", ";", "if", "(", "resolutionCycleStartIndex", ">=", "0", ")", "{", "var", "length_2", "=", "resolutionTargets", ".", "length", ";", "for", "(", "var", "i", "=", "resolutionCycleStartIndex", ";", "i", "<", "length_2", ";", "i", "++", ")", "{", "resolutionResults", "[", "i", "]", "=", "false", ";", "}", "return", "false", ";", "}", "resolutionTargets", ".", "push", "(", "target", ")", ";", "resolutionResults", ".", "push", "(", "true", ")", ";", "resolutionPropertyNames", ".", "push", "(", "propertyName", ")", ";", "return", "true", ";", "}" ]

[ "Push", "an", "entry", "on", "the", "type", "resolution", "stack", ".", "If", "an", "entry", "with", "the", "given", "target", "and", "the", "given", "property", "name", "is", "already", "on", "the", "stack", "and", "no", "entries", "in", "between", "already", "have", "a", "type", "then", "a", "circularity", "has", "occurred", ".", "In", "this", "case", "the", "result", "values", "of", "the", "existing", "entry", "and", "all", "entries", "pushed", "after", "it", "are", "changed", "to", "false", "and", "the", "value", "false", "is", "returned", ".", "Otherwise", "the", "new", "entry", "is", "just", "pushed", "onto", "the", "stack", "and", "true", "is", "returned", ".", "In", "order", "to", "see", "if", "the", "same", "query", "has", "already", "been", "done", "before", "the", "target", "object", "and", "the", "propertyName", "both", "must", "match", "the", "one", "passed", "in", "." ]

[ "function", "getTypeForBindingElement", "(", "declaration", ")", "{", "var", "pattern", "=", "declaration", ".", "parent", ";", "var", "parentType", "=", "getTypeForBindingElementParent", "(", "pattern", ".", "parent", ")", ";", "if", "(", "parentType", "===", "unknownType", ")", "{", "return", "unknownType", ";", "}", "if", "(", "!", "parentType", "||", "isTypeAny", "(", "parentType", ")", ")", "{", "if", "(", "declaration", ".", "initializer", ")", "{", "return", "checkExpressionCached", "(", "declaration", ".", "initializer", ")", ";", "}", "return", "parentType", ";", "}", "var", "type", ";", "if", "(", "pattern", ".", "kind", "===", "167", ")", "{", "var", "name_11", "=", "declaration", ".", "propertyName", "||", "declaration", ".", "name", ";", "if", "(", "isComputedNonLiteralName", "(", "name_11", ")", ")", "{", "return", "anyType", ";", "}", "if", "(", "declaration", ".", "initializer", ")", "{", "getContextualType", "(", "declaration", ".", "initializer", ")", ";", "}", "var", "text", "=", "getTextOfPropertyName", "(", "name_11", ")", ";", "type", "=", "getTypeOfPropertyOfType", "(", "parentType", ",", "text", ")", "||", "isNumericLiteralName", "(", "text", ")", "&&", "getIndexTypeOfType", "(", "parentType", ",", "1", ")", "||", "getIndexTypeOfType", "(", "parentType", ",", "0", ")", ";", "if", "(", "!", "type", ")", "{", "error", "(", "name_11", ",", "ts", ".", "Diagnostics", ".", "Type_0_has_no_property_1_and_no_string_index_signature", ",", "typeToString", "(", "parentType", ")", ",", "ts", ".", "declarationNameToString", "(", "name_11", ")", ")", ";", "return", "unknownType", ";", "}", "}", "else", "{", "var", "elementType", "=", "checkIteratedTypeOrElementType", "(", "parentType", ",", "pattern", ",", "false", ")", ";", "if", "(", "!", "declaration", ".", "dotDotDotToken", ")", "{", "var", "propName", "=", "\"\"", "+", "ts", ".", "indexOf", "(", "pattern", ".", "elements", ",", "declaration", ")", ";", "type", "=", "isTupleLikeType", "(", "parentType", ")", "?", "getTypeOfPropertyOfType", "(", "parentType", ",", "propName", ")", ":", "elementType", ";", "if", "(", "!", "type", ")", "{", "if", "(", "isTupleType", "(", "parentType", ")", ")", "{", "error", "(", "declaration", ",", "ts", ".", "Diagnostics", ".", "Tuple_type_0_with_length_1_cannot_be_assigned_to_tuple_with_length_2", ",", "typeToString", "(", "parentType", ")", ",", "getTypeReferenceArity", "(", "parentType", ")", ",", "pattern", ".", "elements", ".", "length", ")", ";", "}", "else", "{", "error", "(", "declaration", ",", "ts", ".", "Diagnostics", ".", "Type_0_has_no_property_1", ",", "typeToString", "(", "parentType", ")", ",", "propName", ")", ";", "}", "return", "unknownType", ";", "}", "}", "else", "{", "type", "=", "createArrayType", "(", "elementType", ")", ";", "}", "}", "if", "(", "strictNullChecks", "&&", "declaration", ".", "initializer", "&&", "!", "(", "getFalsyFlags", "(", "checkExpressionCached", "(", "declaration", ".", "initializer", ")", ")", "&", "2048", ")", ")", "{", "type", "=", "getTypeWithFacts", "(", "type", ",", "131072", ")", ";", "}", "return", "declaration", ".", "initializer", "?", "getUnionType", "(", "[", "type", ",", "checkExpressionCached", "(", "declaration", ".", "initializer", ")", "]", ",", "true", ")", ":", "type", ";", "}" ]

[ "Return", "the", "inferred", "type", "for", "a", "binding", "element" ]

[ "function", "getTypeForVariableLikeDeclaration", "(", "declaration", ",", "includeOptionality", ")", "{", "if", "(", "declaration", ".", "flags", "&", "134217728", ")", "{", "var", "type", "=", "getTypeForVariableLikeDeclarationFromJSDocComment", "(", "declaration", ")", ";", "if", "(", "type", "&&", "type", "!==", "unknownType", ")", "{", "return", "type", ";", "}", "}", "if", "(", "declaration", ".", "parent", ".", "parent", ".", "kind", "===", "207", ")", "{", "return", "stringType", ";", "}", "if", "(", "declaration", ".", "parent", ".", "parent", ".", "kind", "===", "208", ")", "{", "return", "checkRightHandSideOfForOf", "(", "declaration", ".", "parent", ".", "parent", ".", "expression", ")", "||", "anyType", ";", "}", "if", "(", "ts", ".", "isBindingPattern", "(", "declaration", ".", "parent", ")", ")", "{", "return", "getTypeForBindingElement", "(", "declaration", ")", ";", "}", "if", "(", "declaration", ".", "type", ")", "{", "return", "addOptionality", "(", "getTypeFromTypeNode", "(", "declaration", ".", "type", ")", ",", "declaration", ".", "questionToken", "&&", "includeOptionality", ")", ";", "}", "if", "(", "declaration", ".", "kind", "===", "142", ")", "{", "var", "func", "=", "declaration", ".", "parent", ";", "if", "(", "func", ".", "kind", "===", "150", "&&", "!", "ts", ".", "hasDynamicName", "(", "func", ")", ")", "{", "var", "getter", "=", "ts", ".", "getDeclarationOfKind", "(", "declaration", ".", "parent", ".", "symbol", ",", "149", ")", ";", "if", "(", "getter", ")", "{", "var", "getterSignature", "=", "getSignatureFromDeclaration", "(", "getter", ")", ";", "var", "thisParameter", "=", "getAccessorThisParameter", "(", "func", ")", ";", "if", "(", "thisParameter", "&&", "declaration", "===", "thisParameter", ")", "{", "ts", ".", "Debug", ".", "assert", "(", "!", "thisParameter", ".", "type", ")", ";", "return", "getTypeOfSymbol", "(", "getterSignature", ".", "thisParameter", ")", ";", "}", "return", "getReturnTypeOfSignature", "(", "getterSignature", ")", ";", "}", "}", "var", "type", "=", "void", "0", ";", "if", "(", "declaration", ".", "symbol", ".", "name", "===", "\"this\"", ")", "{", "var", "thisParameter", "=", "getContextualThisParameter", "(", "func", ")", ";", "type", "=", "thisParameter", "?", "getTypeOfSymbol", "(", "thisParameter", ")", ":", "undefined", ";", "}", "else", "{", "type", "=", "getContextuallyTypedParameterType", "(", "declaration", ")", ";", "}", "if", "(", "type", ")", "{", "return", "addOptionality", "(", "type", ",", "declaration", ".", "questionToken", "&&", "includeOptionality", ")", ";", "}", "}", "if", "(", "declaration", ".", "initializer", ")", "{", "return", "addOptionality", "(", "checkExpressionCached", "(", "declaration", ".", "initializer", ")", ",", "declaration", ".", "questionToken", "&&", "includeOptionality", ")", ";", "}", "if", "(", "declaration", ".", "kind", "===", "254", ")", "{", "return", "checkIdentifier", "(", "declaration", ".", "name", ")", ";", "}", "if", "(", "ts", ".", "isBindingPattern", "(", "declaration", ".", "name", ")", ")", "{", "return", "getTypeFromBindingPattern", "(", "declaration", ".", "name", ",", "false", ",", "true", ")", ";", "}", "return", "undefined", ";", "}" ]

[ "Return", "the", "inferred", "type", "for", "a", "variable", "parameter", "or", "property", "declaration" ]

[ "function", "getTypeFromBindingElement", "(", "element", ",", "includePatternInType", ",", "reportErrors", ")", "{", "if", "(", "element", ".", "initializer", ")", "{", "return", "checkExpressionCached", "(", "element", ".", "initializer", ")", ";", "}", "if", "(", "ts", ".", "isBindingPattern", "(", "element", ".", "name", ")", ")", "{", "return", "getTypeFromBindingPattern", "(", "element", ".", "name", ",", "includePatternInType", ",", "reportErrors", ")", ";", "}", "if", "(", "reportErrors", "&&", "compilerOptions", ".", "noImplicitAny", "&&", "!", "declarationBelongsToPrivateAmbientMember", "(", "element", ")", ")", "{", "reportImplicitAnyError", "(", "element", ",", "anyType", ")", ";", "}", "return", "anyType", ";", "}" ]

[ "Return", "the", "type", "implied", "by", "a", "binding", "pattern", "element", ".", "This", "is", "the", "type", "of", "the", "initializer", "of", "the", "element", "if", "one", "is", "present", ".", "Otherwise", "if", "the", "element", "is", "itself", "a", "binding", "pattern", "it", "is", "the", "type", "implied", "by", "the", "binding", "pattern", ".", "Otherwise", "it", "is", "the", "type", "any", "." ]

[ "function", "getTypeFromObjectBindingPattern", "(", "pattern", ",", "includePatternInType", ",", "reportErrors", ")", "{", "var", "members", "=", "ts", ".", "createMap", "(", ")", ";", "var", "hasComputedProperties", "=", "false", ";", "ts", ".", "forEach", "(", "pattern", ".", "elements", ",", "function", "(", "e", ")", "{", "var", "name", "=", "e", ".", "propertyName", "||", "e", ".", "name", ";", "if", "(", "isComputedNonLiteralName", "(", "name", ")", ")", "{", "hasComputedProperties", "=", "true", ";", "return", ";", "}", "var", "text", "=", "getTextOfPropertyName", "(", "name", ")", ";", "var", "flags", "=", "4", "|", "67108864", "|", "(", "e", ".", "initializer", "?", "536870912", ":", "0", ")", ";", "var", "symbol", "=", "createSymbol", "(", "flags", ",", "text", ")", ";", "symbol", ".", "type", "=", "getTypeFromBindingElement", "(", "e", ",", "includePatternInType", ",", "reportErrors", ")", ";", "symbol", ".", "bindingElement", "=", "e", ";", "members", "[", "symbol", ".", "name", "]", "=", "symbol", ";", "}", ")", ";", "var", "result", "=", "createAnonymousType", "(", "undefined", ",", "members", ",", "emptyArray", ",", "emptyArray", ",", "undefined", ",", "undefined", ")", ";", "if", "(", "includePatternInType", ")", "{", "result", ".", "pattern", "=", "pattern", ";", "}", "if", "(", "hasComputedProperties", ")", "{", "result", ".", "flags", "|=", "536870912", ";", "}", "return", "result", ";", "}" ]

[ "Return", "the", "type", "implied", "by", "an", "object", "binding", "pattern" ]

[ "function", "getTypeFromArrayBindingPattern", "(", "pattern", ",", "includePatternInType", ",", "reportErrors", ")", "{", "var", "elements", "=", "pattern", ".", "elements", ";", "if", "(", "elements", ".", "length", "===", "0", "||", "elements", "[", "elements", ".", "length", "-", "1", "]", ".", "dotDotDotToken", ")", "{", "return", "languageVersion", ">=", "2", "?", "createIterableType", "(", "anyType", ")", ":", "anyArrayType", ";", "}", "var", "elementTypes", "=", "ts", ".", "map", "(", "elements", ",", "function", "(", "e", ")", "{", "return", "e", ".", "kind", "===", "193", "?", "anyType", ":", "getTypeFromBindingElement", "(", "e", ",", "includePatternInType", ",", "reportErrors", ")", ";", "}", ")", ";", "var", "result", "=", "createTupleType", "(", "elementTypes", ")", ";", "if", "(", "includePatternInType", ")", "{", "result", "=", "cloneTypeReference", "(", "result", ")", ";", "result", ".", "pattern", "=", "pattern", ";", "}", "return", "result", ";", "}" ]

[ "Return", "the", "type", "implied", "by", "an", "array", "binding", "pattern" ]

[ "function", "appendTypeParameters", "(", "typeParameters", ",", "declarations", ")", "{", "for", "(", "var", "_i", "=", "0", ",", "declarations_2", "=", "declarations", ";", "_i", "<", "declarations_2", ".", "length", ";", "_i", "++", ")", "{", "var", "declaration", "=", "declarations_2", "[", "_i", "]", ";", "var", "tp", "=", "getDeclaredTypeOfTypeParameter", "(", "getSymbolOfNode", "(", "declaration", ")", ")", ";", "if", "(", "!", "typeParameters", ")", "{", "typeParameters", "=", "[", "tp", "]", ";", "}", "else", "if", "(", "!", "ts", ".", "contains", "(", "typeParameters", ",", "tp", ")", ")", "{", "typeParameters", ".", "push", "(", "tp", ")", ";", "}", "}", "return", "typeParameters", ";", "}" ]

[ "Appends", "the", "type", "parameters", "given", "by", "a", "list", "of", "declarations", "to", "a", "set", "of", "type", "parameters", "and", "returns", "the", "resulting", "set", ".", "The", "function", "allocates", "a", "new", "array", "if", "the", "input", "type", "parameter", "set", "is", "undefined", "but", "otherwise", "it", "modifies", "the", "set", "in", "-", "place", "and", "returns", "the", "same", "array", "." ]

[ "function", "appendOuterTypeParameters", "(", "typeParameters", ",", "node", ")", "{", "while", "(", "true", ")", "{", "node", "=", "node", ".", "parent", ";", "if", "(", "!", "node", ")", "{", "return", "typeParameters", ";", "}", "if", "(", "node", ".", "kind", "===", "221", "||", "node", ".", "kind", "===", "192", "||", "node", ".", "kind", "===", "220", "||", "node", ".", "kind", "===", "179", "||", "node", ".", "kind", "===", "147", "||", "node", ".", "kind", "===", "180", ")", "{", "var", "declarations", "=", "node", ".", "typeParameters", ";", "if", "(", "declarations", ")", "{", "return", "appendTypeParameters", "(", "appendOuterTypeParameters", "(", "typeParameters", ",", "node", ")", ",", "declarations", ")", ";", "}", "}", "}", "}" ]

[ "Appends", "the", "outer", "type", "parameters", "of", "a", "node", "to", "a", "set", "of", "type", "parameters", "and", "returns", "the", "resulting", "set", ".", "The", "function", "allocates", "a", "new", "array", "if", "the", "input", "type", "parameter", "set", "is", "undefined", "but", "otherwise", "it", "modifies", "the", "set", "in", "-", "place", "and", "returns", "the", "same", "array", "." ]

[ "function", "getOuterTypeParametersOfClassOrInterface", "(", "symbol", ")", "{", "var", "declaration", "=", "symbol", ".", "flags", "&", "32", "?", "symbol", ".", "valueDeclaration", ":", "ts", ".", "getDeclarationOfKind", "(", "symbol", ",", "222", ")", ";", "return", "appendOuterTypeParameters", "(", "undefined", ",", "declaration", ")", ";", "}" ]

[ "The", "outer", "type", "parameters", "are", "those", "defined", "by", "enclosing", "generic", "classes", "methods", "or", "functions", "." ]

[ "function", "isIndependentInterface", "(", "symbol", ")", "{", "for", "(", "var", "_i", "=", "0", ",", "_a", "=", "symbol", ".", "declarations", ";", "_i", "<", "_a", ".", "length", ";", "_i", "++", ")", "{", "var", "declaration", "=", "_a", "[", "_i", "]", ";", "if", "(", "declaration", ".", "kind", "===", "222", ")", "{", "if", "(", "declaration", ".", "flags", "&", "16384", ")", "{", "return", "false", ";", "}", "var", "baseTypeNodes", "=", "ts", ".", "getInterfaceBaseTypeNodes", "(", "declaration", ")", ";", "if", "(", "baseTypeNodes", ")", "{", "for", "(", "var", "_b", "=", "0", ",", "baseTypeNodes_1", "=", "baseTypeNodes", ";", "_b", "<", "baseTypeNodes_1", ".", "length", ";", "_b", "++", ")", "{", "var", "node", "=", "baseTypeNodes_1", "[", "_b", "]", ";", "if", "(", "ts", ".", "isEntityNameExpression", "(", "node", ".", "expression", ")", ")", "{", "var", "baseSymbol", "=", "resolveEntityName", "(", "node", ".", "expression", ",", "793064", ",", "true", ")", ";", "if", "(", "!", "baseSymbol", "||", "!", "(", "baseSymbol", ".", "flags", "&", "64", ")", "||", "getDeclaredTypeOfClassOrInterface", "(", "baseSymbol", ")", ".", "thisType", ")", "{", "return", "false", ";", "}", "}", "}", "}", "}", "}", "return", "true", ";", "}" ]

[ "Returns", "true", "if", "the", "interface", "given", "by", "the", "symbol", "is", "free", "of", "this", "references", ".", "Specifically", "the", "result", "is", "true", "if", "the", "interface", "itself", "contains", "no", "references", "to", "this", "in", "its", "body", "if", "all", "base", "types", "are", "interfaces", "and", "if", "none", "of", "the", "base", "interfaces", "have", "a", "this", "type", "." ]

[ "function", "isIndependentType", "(", "node", ")", "{", "switch", "(", "node", ".", "kind", ")", "{", "case", "117", ":", "case", "132", ":", "case", "130", ":", "case", "120", ":", "case", "133", ":", "case", "103", ":", "case", "135", ":", "case", "93", ":", "case", "127", ":", "case", "166", ":", "return", "true", ";", "case", "160", ":", "return", "isIndependentType", "(", "node", ".", "elementType", ")", ";", "case", "155", ":", "return", "isIndependentTypeReference", "(", "node", ")", ";", "}", "return", "false", ";", "}" ]

[ "A", "type", "is", "considered", "independent", "if", "it", "the", "any", "string", "number", "boolean", "symbol", "or", "void", "keyword", "a", "string", "literal", "type", "an", "array", "with", "an", "element", "type", "that", "is", "considered", "independent", "or", "a", "type", "reference", "that", "is", "considered", "independent", "." ]

[ "function", "isIndependentMember", "(", "symbol", ")", "{", "if", "(", "symbol", ".", "declarations", "&&", "symbol", ".", "declarations", ".", "length", "===", "1", ")", "{", "var", "declaration", "=", "symbol", ".", "declarations", "[", "0", "]", ";", "if", "(", "declaration", ")", "{", "switch", "(", "declaration", ".", "kind", ")", "{", "case", "145", ":", "case", "144", ":", "return", "isIndependentVariableLikeDeclaration", "(", "declaration", ")", ";", "case", "147", ":", "case", "146", ":", "case", "148", ":", "return", "isIndependentFunctionLikeDeclaration", "(", "declaration", ")", ";", "}", "}", "}", "return", "false", ";", "}" ]

[ "Returns", "true", "if", "the", "class", "or", "interface", "member", "given", "by", "the", "symbol", "is", "free", "of", "this", "references", ".", "The", "function", "may", "return", "false", "for", "symbols", "that", "are", "actually", "free", "of", "this", "references", "because", "it", "is", "not", "feasible", "to", "perform", "a", "complete", "analysis", "in", "all", "cases", ".", "In", "particular", "property", "members", "with", "types", "inferred", "from", "their", "initializers", "and", "function", "members", "with", "inferred", "return", "types", "are", "conservatively", "assumed", "not", "to", "be", "free", "of", "this", "references", "." ]

[ "function", "createInstantiatedSymbolTable", "(", "symbols", ",", "mapper", ",", "mappingThisOnly", ")", "{", "var", "result", "=", "ts", ".", "createMap", "(", ")", ";", "for", "(", "var", "_i", "=", "0", ",", "symbols_2", "=", "symbols", ";", "_i", "<", "symbols_2", ".", "length", ";", "_i", "++", ")", "{", "var", "symbol", "=", "symbols_2", "[", "_i", "]", ";", "result", "[", "symbol", ".", "name", "]", "=", "mappingThisOnly", "&&", "isIndependentMember", "(", "symbol", ")", "?", "symbol", ":", "instantiateSymbol", "(", "symbol", ",", "mapper", ")", ";", "}", "return", "result", ";", "}" ]

[ "The", "mappingThisOnly", "flag", "indicates", "that", "the", "only", "type", "parameter", "being", "mapped", "is", "this", ".", "When", "the", "flag", "is", "true", "we", "check", "symbols", "to", "see", "if", "we", "can", "quickly", "conclude", "they", "are", "free", "of", "this", "references", "thus", "needing", "no", "instantiation", "." ]

[ "function", "getUnionSignatures", "(", "types", ",", "kind", ")", "{", "var", "signatureLists", "=", "ts", ".", "map", "(", "types", ",", "function", "(", "t", ")", "{", "return", "getSignaturesOfType", "(", "t", ",", "kind", ")", ";", "}", ")", ";", "var", "result", "=", "undefined", ";", "for", "(", "var", "i", "=", "0", ";", "i", "<", "signatureLists", ".", "length", ";", "i", "++", ")", "{", "for", "(", "var", "_i", "=", "0", ",", "_a", "=", "signatureLists", "[", "i", "]", ";", "_i", "<", "_a", ".", "length", ";", "_i", "++", ")", "{", "var", "signature", "=", "_a", "[", "_i", "]", ";", "if", "(", "!", "result", "||", "!", "findMatchingSignature", "(", "result", ",", "signature", ",", "false", ",", "true", ",", "true", ")", ")", "{", "var", "unionSignatures", "=", "findMatchingSignatures", "(", "signatureLists", ",", "signature", ",", "i", ")", ";", "if", "(", "unionSignatures", ")", "{", "var", "s", "=", "signature", ";", "if", "(", "unionSignatures", ".", "length", ">", "1", ")", "{", "s", "=", "cloneSignature", "(", "signature", ")", ";", "if", "(", "ts", ".", "forEach", "(", "unionSignatures", ",", "function", "(", "sig", ")", "{", "return", "sig", ".", "thisParameter", ";", "}", ")", ")", "{", "var", "thisType", "=", "getUnionType", "(", "ts", ".", "map", "(", "unionSignatures", ",", "function", "(", "sig", ")", "{", "return", "getTypeOfSymbol", "(", "sig", ".", "thisParameter", ")", "||", "anyType", ";", "}", ")", ",", "true", ")", ";", "s", ".", "thisParameter", "=", "createTransientSymbol", "(", "signature", ".", "thisParameter", ",", "thisType", ")", ";", "}", "s", ".", "resolvedReturnType", "=", "undefined", ";", "s", ".", "unionSignatures", "=", "unionSignatures", ";", "}", "(", "result", "||", "(", "result", "=", "[", "]", ")", ")", ".", "push", "(", "s", ")", ";", "}", "}", "}", "}", "return", "result", "||", "emptyArray", ";", "}" ]

[ "The", "signatures", "of", "a", "union", "type", "are", "those", "signatures", "that", "are", "present", "in", "each", "of", "the", "constituent", "types", ".", "Generic", "signatures", "must", "match", "exactly", "but", "non", "-", "generic", "signatures", "are", "allowed", "to", "have", "extra", "optional", "parameters", "and", "may", "differ", "in", "return", "types", ".", "When", "signatures", "differ", "in", "return", "types", "the", "resulting", "return", "type", "is", "the", "union", "of", "the", "constituent", "return", "types", "." ]

[ "function", "getApparentTypeOfTypeParameter", "(", "type", ")", "{", "if", "(", "!", "type", ".", "resolvedApparentType", ")", "{", "var", "constraintType", "=", "getConstraintOfTypeParameter", "(", "type", ")", ";", "while", "(", "constraintType", "&&", "constraintType", ".", "flags", "&", "16384", ")", "{", "constraintType", "=", "getConstraintOfTypeParameter", "(", "constraintType", ")", ";", "}", "type", ".", "resolvedApparentType", "=", "getTypeWithThisArgument", "(", "constraintType", "||", "emptyObjectType", ",", "type", ")", ";", "}", "return", "type", ".", "resolvedApparentType", ";", "}" ]

[ "The", "apparent", "type", "of", "a", "type", "parameter", "is", "the", "base", "constraint", "instantiated", "with", "the", "type", "parameter", "as", "the", "type", "argument", "for", "the", "this", "type", "." ]

[ "function", "getApparentType", "(", "type", ")", "{", "if", "(", "type", ".", "flags", "&", "16384", ")", "{", "type", "=", "getApparentTypeOfTypeParameter", "(", "type", ")", ";", "}", "if", "(", "type", ".", "flags", "&", "34", ")", "{", "type", "=", "globalStringType", ";", "}", "else", "if", "(", "type", ".", "flags", "&", "340", ")", "{", "type", "=", "globalNumberType", ";", "}", "else", "if", "(", "type", ".", "flags", "&", "136", ")", "{", "type", "=", "globalBooleanType", ";", "}", "else", "if", "(", "type", ".", "flags", "&", "512", ")", "{", "type", "=", "getGlobalESSymbolType", "(", ")", ";", "}", "return", "type", ";", "}" ]

[ "For", "a", "type", "parameter", "return", "the", "base", "constraint", "of", "the", "type", "parameter", ".", "For", "the", "string", "number", "boolean", "and", "symbol", "primitive", "types", "return", "the", "corresponding", "object", "types", ".", "Otherwise", "return", "the", "type", "itself", ".", "Note", "that", "the", "apparent", "type", "of", "a", "union", "type", "is", "the", "union", "type", "itself", "." ]

[ "function", "getPropagatingFlagsOfTypes", "(", "types", ",", "excludeKinds", ")", "{", "var", "result", "=", "0", ";", "for", "(", "var", "_i", "=", "0", ",", "types_3", "=", "types", ";", "_i", "<", "types_3", ".", "length", ";", "_i", "++", ")", "{", "var", "type", "=", "types_3", "[", "_i", "]", ";", "if", "(", "!", "(", "type", ".", "flags", "&", "excludeKinds", ")", ")", "{", "result", "|=", "type", ".", "flags", ";", "}", "}", "return", "result", "&", "234881024", ";", "}" ]

[ "This", "function", "is", "used", "to", "propagate", "certain", "flags", "when", "creating", "new", "object", "type", "references", "and", "union", "types", ".", "It", "is", "only", "necessary", "to", "do", "so", "if", "a", "constituent", "type", "might", "be", "the", "undefined", "type", "the", "null", "type", "the", "type", "of", "an", "object", "literal", "or", "the", "anyFunctionType", ".", "This", "is", "because", "there", "are", "operations", "in", "the", "type", "checker", "that", "care", "about", "the", "presence", "of", "such", "types", "at", "arbitrary", "depth", "in", "a", "containing", "type", "." ]

[ "function", "getUnionTypeFromSortedList", "(", "types", ",", "aliasSymbol", ",", "aliasTypeArguments", ")", "{", "if", "(", "types", ".", "length", "===", "0", ")", "{", "return", "neverType", ";", "}", "if", "(", "types", ".", "length", "===", "1", ")", "{", "return", "types", "[", "0", "]", ";", "}", "var", "id", "=", "getTypeListId", "(", "types", ")", ";", "var", "type", "=", "unionTypes", "[", "id", "]", ";", "if", "(", "!", "type", ")", "{", "var", "propagatedFlags", "=", "getPropagatingFlagsOfTypes", "(", "types", ",", "6144", ")", ";", "type", "=", "unionTypes", "[", "id", "]", "=", "createObjectType", "(", "524288", "|", "propagatedFlags", ")", ";", "type", ".", "types", "=", "types", ";", "type", ".", "aliasSymbol", "=", "aliasSymbol", ";", "type", ".", "aliasTypeArguments", "=", "aliasTypeArguments", ";", "}", "return", "type", ";", "}" ]

[ "This", "function", "assumes", "the", "constituent", "type", "list", "is", "sorted", "and", "deduplicated", "." ]

[ "function", "isKnownProperty", "(", "type", ",", "name", ")", "{", "if", "(", "type", ".", "flags", "&", "2588672", ")", "{", "var", "resolved", "=", "resolveStructuredTypeMembers", "(", "type", ")", ";", "if", "(", "(", "relation", "===", "assignableRelation", "||", "relation", "===", "comparableRelation", ")", "&&", "(", "type", "===", "globalObjectType", "||", "isEmptyObjectType", "(", "resolved", ")", ")", "||", "resolved", ".", "stringIndexInfo", "||", "(", "resolved", ".", "numberIndexInfo", "&&", "isNumericLiteralName", "(", "name", ")", ")", "||", "getPropertyOfType", "(", "type", ",", "name", ")", ")", "{", "return", "true", ";", "}", "}", "else", "if", "(", "type", ".", "flags", "&", "1572864", ")", "{", "for", "(", "var", "_i", "=", "0", ",", "_a", "=", "type", ".", "types", ";", "_i", "<", "_a", ".", "length", ";", "_i", "++", ")", "{", "var", "t", "=", "_a", "[", "_i", "]", ";", "if", "(", "isKnownProperty", "(", "t", ",", "name", ")", ")", "{", "return", "true", ";", "}", "}", "}", "return", "false", ";", "}" ]

[ "Check", "if", "a", "property", "with", "the", "given", "name", "is", "known", "anywhere", "in", "the", "given", "type", ".", "In", "an", "object", "type", "a", "property", "is", "considered", "known", "if", "the", "object", "type", "is", "empty", "and", "the", "check", "is", "for", "assignability", "if", "the", "object", "type", "has", "index", "signatures", "or", "if", "the", "property", "is", "actually", "declared", "in", "the", "object", "type", ".", "In", "a", "union", "or", "intersection", "type", "a", "property", "is", "considered", "known", "if", "it", "is", "known", "in", "any", "constituent", "type", "." ]

[ "function", "objectTypeRelatedTo", "(", "source", ",", "originalSource", ",", "target", ",", "reportErrors", ")", "{", "if", "(", "overflow", ")", "{", "return", "0", ";", "}", "var", "id", "=", "relation", "!==", "identityRelation", "||", "source", ".", "id", "<", "target", ".", "id", "?", "source", ".", "id", "+", "\",\"", "+", "target", ".", "id", ":", "target", ".", "id", "+", "\",\"", "+", "source", ".", "id", ";", "var", "related", "=", "relation", "[", "id", "]", ";", "if", "(", "related", "!==", "undefined", ")", "{", "if", "(", "reportErrors", "&&", "related", "===", "2", ")", "{", "relation", "[", "id", "]", "=", "3", ";", "}", "else", "{", "return", "related", "===", "1", "?", "-", "1", ":", "0", ";", "}", "}", "if", "(", "depth", ">", "0", ")", "{", "for", "(", "var", "i", "=", "0", ";", "i", "<", "depth", ";", "i", "++", ")", "{", "if", "(", "maybeStack", "[", "i", "]", "[", "id", "]", ")", "{", "return", "1", ";", "}", "}", "if", "(", "depth", "===", "100", ")", "{", "overflow", "=", "true", ";", "return", "0", ";", "}", "}", "else", "{", "sourceStack", "=", "[", "]", ";", "targetStack", "=", "[", "]", ";", "maybeStack", "=", "[", "]", ";", "expandingFlags", "=", "0", ";", "}", "sourceStack", "[", "depth", "]", "=", "source", ";", "targetStack", "[", "depth", "]", "=", "target", ";", "maybeStack", "[", "depth", "]", "=", "ts", ".", "createMap", "(", ")", ";", "maybeStack", "[", "depth", "]", "[", "id", "]", "=", "1", ";", "depth", "++", ";", "var", "saveExpandingFlags", "=", "expandingFlags", ";", "if", "(", "!", "(", "expandingFlags", "&", "1", ")", "&&", "isDeeplyNestedGeneric", "(", "source", ",", "sourceStack", ",", "depth", ")", ")", "expandingFlags", "|=", "1", ";", "if", "(", "!", "(", "expandingFlags", "&", "2", ")", "&&", "isDeeplyNestedGeneric", "(", "target", ",", "targetStack", ",", "depth", ")", ")", "expandingFlags", "|=", "2", ";", "var", "result", ";", "if", "(", "expandingFlags", "===", "3", ")", "{", "result", "=", "1", ";", "}", "else", "{", "result", "=", "propertiesRelatedTo", "(", "source", ",", "target", ",", "reportErrors", ")", ";", "if", "(", "result", ")", "{", "result", "&=", "signaturesRelatedTo", "(", "source", ",", "target", ",", "0", ",", "reportErrors", ")", ";", "if", "(", "result", ")", "{", "result", "&=", "signaturesRelatedTo", "(", "source", ",", "target", ",", "1", ",", "reportErrors", ")", ";", "if", "(", "result", ")", "{", "result", "&=", "indexTypesRelatedTo", "(", "source", ",", "originalSource", ",", "target", ",", "0", ",", "reportErrors", ")", ";", "if", "(", "result", ")", "{", "result", "&=", "indexTypesRelatedTo", "(", "source", ",", "originalSource", ",", "target", ",", "1", ",", "reportErrors", ")", ";", "}", "}", "}", "}", "}", "expandingFlags", "=", "saveExpandingFlags", ";", "depth", "--", ";", "if", "(", "result", ")", "{", "var", "maybeCache", "=", "maybeStack", "[", "depth", "]", ";", "var", "destinationCache", "=", "(", "result", "===", "-", "1", "||", "depth", "===", "0", ")", "?", "relation", ":", "maybeStack", "[", "depth", "-", "1", "]", ";", "ts", ".", "copyProperties", "(", "maybeCache", ",", "destinationCache", ")", ";", "}", "else", "{", "relation", "[", "id", "]", "=", "reportErrors", "?", "3", ":", "2", ";", "}", "return", "result", ";", "}" ]

[ "Determine", "if", "two", "object", "types", "are", "related", "by", "structure", ".", "First", "check", "if", "the", "result", "is", "already", "available", "in", "the", "global", "cache", ".", "Second", "check", "if", "we", "have", "already", "started", "a", "comparison", "of", "the", "given", "two", "types", "in", "which", "case", "we", "assume", "the", "result", "to", "be", "true", ".", "Third", "check", "if", "both", "types", "are", "part", "of", "deeply", "nested", "chains", "of", "generic", "type", "instantiations", "and", "if", "so", "assume", "the", "types", "are", "equal", "and", "infinitely", "expanding", ".", "Fourth", "if", "we", "have", "reached", "a", "depth", "of", "100", "nested", "comparisons", "assume", "we", "have", "runaway", "recursion", "and", "issue", "an", "error", ".", "Otherwise", "actually", "compare", "the", "structure", "of", "the", "two", "types", "." ]

[ "function", "signatureRelatedTo", "(", "source", ",", "target", ",", "reportErrors", ")", "{", "return", "compareSignaturesRelated", "(", "source", ",", "target", ",", "false", ",", "reportErrors", ",", "reportError", ",", "isRelatedTo", ")", ";", "}" ]

[ "See", "signatureAssignableTo", "compareSignaturesIdentical" ]

[ "function", "isAbstractConstructorType", "(", "type", ")", "{", "if", "(", "type", ".", "flags", "&", "2097152", ")", "{", "var", "symbol", "=", "type", ".", "symbol", ";", "if", "(", "symbol", "&&", "symbol", ".", "flags", "&", "32", ")", "{", "var", "declaration", "=", "getClassLikeDeclarationOfSymbol", "(", "symbol", ")", ";", "if", "(", "declaration", "&&", "declaration", ".", "flags", "&", "128", ")", "{", "return", "true", ";", "}", "}", "}", "return", "false", ";", "}" ]

[ "Return", "true", "if", "the", "given", "type", "is", "the", "constructor", "type", "for", "an", "abstract", "class" ]

[ "function", "isObjectLiteralType", "(", "type", ")", "{", "return", "type", ".", "symbol", "&&", "(", "type", ".", "symbol", ".", "flags", "&", "(", "4096", "|", "2048", ")", ")", "!==", "0", "&&", "getSignaturesOfType", "(", "type", ",", "0", ")", ".", "length", "===", "0", "&&", "getSignaturesOfType", "(", "type", ",", "1", ")", ".", "length", "===", "0", ";", "}" ]

[ "Return", "true", "if", "type", "was", "inferred", "from", "an", "object", "literal", "or", "written", "as", "an", "object", "type", "literal", "with", "no", "call", "or", "construct", "signatures", "." ]

[ "function", "getRegularTypeOfObjectLiteral", "(", "type", ")", "{", "if", "(", "!", "(", "type", ".", "flags", "&", "16777216", ")", ")", "{", "return", "type", ";", "}", "var", "regularType", "=", "type", ".", "regularType", ";", "if", "(", "regularType", ")", "{", "return", "regularType", ";", "}", "var", "resolved", "=", "type", ";", "var", "members", "=", "transformTypeOfMembers", "(", "type", ",", "getRegularTypeOfObjectLiteral", ")", ";", "var", "regularNew", "=", "createAnonymousType", "(", "resolved", ".", "symbol", ",", "members", ",", "resolved", ".", "callSignatures", ",", "resolved", ".", "constructSignatures", ",", "resolved", ".", "stringIndexInfo", ",", "resolved", ".", "numberIndexInfo", ")", ";", "regularNew", ".", "flags", "=", "resolved", ".", "flags", "&", "~", "16777216", ";", "type", ".", "regularType", "=", "regularNew", ";", "return", "regularNew", ";", "}" ]

[ "If", "the", "the", "provided", "object", "literal", "is", "subject", "to", "the", "excess", "properties", "check", "create", "a", "new", "that", "is", "exempt", ".", "Recursively", "mark", "object", "literal", "members", "as", "exempt", ".", "Leave", "signatures", "alone", "since", "they", "are", "not", "subject", "to", "the", "check", "." ]

[ "function", "removeTypesFromUnionOrIntersection", "(", "type", ",", "typesToRemove", ")", "{", "var", "reducedTypes", "=", "[", "]", ";", "for", "(", "var", "_i", "=", "0", ",", "_a", "=", "type", ".", "types", ";", "_i", "<", "_a", ".", "length", ";", "_i", "++", ")", "{", "var", "t", "=", "_a", "[", "_i", "]", ";", "if", "(", "!", "typeIdenticalToSomeType", "(", "t", ",", "typesToRemove", ")", ")", "{", "reducedTypes", ".", "push", "(", "t", ")", ";", "}", "}", "return", "type", ".", "flags", "&", "524288", "?", "getUnionType", "(", "reducedTypes", ")", ":", "getIntersectionType", "(", "reducedTypes", ")", ";", "}" ]

[ "Return", "a", "new", "union", "or", "intersection", "type", "computed", "by", "removing", "a", "given", "set", "of", "types", "from", "a", "given", "union", "or", "intersection", "type", "." ]

[ "function", "getResolvedSymbol", "(", "node", ")", "{", "var", "links", "=", "getNodeLinks", "(", "node", ")", ";", "if", "(", "!", "links", ".", "resolvedSymbol", ")", "{", "links", ".", "resolvedSymbol", "=", "!", "ts", ".", "nodeIsMissing", "(", "node", ")", "&&", "resolveName", "(", "node", ",", "node", ".", "text", ",", "107455", "|", "1048576", ",", "ts", ".", "Diagnostics", ".", "Cannot_find_name_0", ",", "node", ")", "||", "unknownSymbol", ";", "}", "return", "links", ".", "resolvedSymbol", ";", "}" ]

[ "EXPRESSION", "TYPE", "CHECKING" ]

[ "function", "containsMatchingReferenceDiscriminant", "(", "source", ",", "target", ")", "{", "return", "target", ".", "kind", "===", "172", "&&", "containsMatchingReference", "(", "source", ",", "target", ".", "expression", ")", "&&", "isDiscriminantProperty", "(", "getDeclaredTypeOfReference", "(", "target", ".", "expression", ")", ",", "target", ".", "name", ".", "text", ")", ";", "}" ]

[ "Return", "true", "if", "target", "is", "a", "property", "access", "xxx", ".", "yyy", "source", "is", "a", "property", "access", "xxx", ".", "zzz", "the", "declared", "type", "of", "xxx", "is", "a", "union", "type", "and", "yyy", "is", "a", "property", "that", "is", "possibly", "a", "discriminant", ".", "We", "consider", "a", "property", "a", "possible", "discriminant", "if", "its", "type", "differs", "in", "the", "constituents", "of", "containing", "union", "type", "and", "if", "every", "choice", "is", "a", "unit", "type", "or", "a", "union", "of", "unit", "types", "." ]

[ "function", "getAssignmentReducedType", "(", "declaredType", ",", "assignedType", ")", "{", "if", "(", "declaredType", "!==", "assignedType", ")", "{", "var", "reducedType", "=", "filterType", "(", "declaredType", ",", "function", "(", "t", ")", "{", "return", "typeMaybeAssignableTo", "(", "assignedType", ",", "t", ")", ";", "}", ")", ";", "if", "(", "reducedType", "!==", "neverType", ")", "{", "return", "reducedType", ";", "}", "}", "return", "declaredType", ";", "}" ]

[ "Remove", "those", "constituent", "types", "of", "declaredType", "to", "which", "no", "constituent", "type", "of", "assignedType", "is", "assignable", ".", "For", "example", "when", "a", "variable", "of", "type", "number", "|", "string", "|", "boolean", "is", "assigned", "a", "value", "of", "type", "number", "|", "boolean", "we", "remove", "type", "string", "." ]

[ "function", "narrowType", "(", "type", ",", "expr", ",", "assumeTrue", ")", "{", "switch", "(", "expr", ".", "kind", ")", "{", "case", "69", ":", "case", "97", ":", "case", "172", ":", "return", "narrowTypeByTruthiness", "(", "type", ",", "expr", ",", "assumeTrue", ")", ";", "case", "174", ":", "return", "narrowTypeByTypePredicate", "(", "type", ",", "expr", ",", "assumeTrue", ")", ";", "case", "178", ":", "return", "narrowType", "(", "type", ",", "expr", ".", "expression", ",", "assumeTrue", ")", ";", "case", "187", ":", "return", "narrowTypeByBinaryExpression", "(", "type", ",", "expr", ",", "assumeTrue", ")", ";", "case", "185", ":", "if", "(", "expr", ".", "operator", "===", "49", ")", "{", "return", "narrowType", "(", "type", ",", "expr", ".", "operand", ",", "!", "assumeTrue", ")", ";", "}", "break", ";", "}", "return", "type", ";", "}" ]

[ "Narrow", "the", "given", "type", "based", "on", "the", "given", "expression", "having", "the", "assumed", "boolean", "value", ".", "The", "returned", "type", "will", "be", "a", "subtype", "or", "the", "same", "type", "as", "the", "argument", "." ]

[ "function", "isParameterAssigned", "(", "symbol", ")", "{", "var", "func", "=", "ts", ".", "getRootDeclaration", "(", "symbol", ".", "valueDeclaration", ")", ".", "parent", ";", "var", "links", "=", "getNodeLinks", "(", "func", ")", ";", "if", "(", "!", "(", "links", ".", "flags", "&", "4194304", ")", ")", "{", "links", ".", "flags", "|=", "4194304", ";", "if", "(", "!", "hasParentWithAssignmentsMarked", "(", "func", ")", ")", "{", "markParameterAssignments", "(", "func", ")", ";", "}", "}", "return", "symbol", ".", "isAssigned", "||", "false", ";", "}" ]

[ "Check", "if", "a", "parameter", "is", "assigned", "anywhere", "within", "its", "declaring", "function", "." ]

[ "function", "getSuperCallInConstructor", "(", "constructor", ")", "{", "var", "links", "=", "getNodeLinks", "(", "constructor", ")", ";", "if", "(", "links", ".", "hasSuperCall", "===", "undefined", ")", "{", "links", ".", "superCall", "=", "findFirstSuperCall", "(", "constructor", ".", "body", ")", ";", "links", ".", "hasSuperCall", "=", "links", ".", "superCall", "?", "true", ":", "false", ";", "}", "return", "links", ".", "superCall", ";", "}" ]

[ "Return", "a", "cached", "result", "if", "super", "-", "statement", "is", "already", "found", ".", "Otherwise", "find", "a", "super", "statement", "in", "a", "given", "constructor", "function", "and", "cache", "the", "result", "in", "the", "node", "-", "links", "of", "the", "constructor" ]

[ "function", "classDeclarationExtendsNull", "(", "classDecl", ")", "{", "var", "classSymbol", "=", "getSymbolOfNode", "(", "classDecl", ")", ";", "var", "classInstanceType", "=", "getDeclaredTypeOfSymbol", "(", "classSymbol", ")", ";", "var", "baseConstructorType", "=", "getBaseConstructorTypeOfClass", "(", "classInstanceType", ")", ";", "return", "baseConstructorType", "===", "nullWideningType", ";", "}" ]

[ "Check", "if", "the", "given", "class", "-", "declaration", "extends", "null", "then", "return", "true", ".", "Otherwise", "return", "false" ]

[ "function", "getContextuallyTypedParameterType", "(", "parameter", ")", "{", "var", "func", "=", "parameter", ".", "parent", ";", "if", "(", "isContextSensitiveFunctionOrObjectLiteralMethod", "(", "func", ")", ")", "{", "var", "iife", "=", "ts", ".", "getImmediatelyInvokedFunctionExpression", "(", "func", ")", ";", "if", "(", "iife", ")", "{", "var", "indexOfParameter", "=", "ts", ".", "indexOf", "(", "func", ".", "parameters", ",", "parameter", ")", ";", "if", "(", "iife", ".", "arguments", "&&", "indexOfParameter", "<", "iife", ".", "arguments", ".", "length", ")", "{", "if", "(", "parameter", ".", "dotDotDotToken", ")", "{", "var", "restTypes", "=", "[", "]", ";", "for", "(", "var", "i", "=", "indexOfParameter", ";", "i", "<", "iife", ".", "arguments", ".", "length", ";", "i", "++", ")", "{", "restTypes", ".", "push", "(", "getTypeOfExpression", "(", "iife", ".", "arguments", "[", "i", "]", ")", ")", ";", "}", "return", "createArrayType", "(", "getUnionType", "(", "restTypes", ")", ")", ";", "}", "var", "links", "=", "getNodeLinks", "(", "iife", ")", ";", "var", "cached", "=", "links", ".", "resolvedSignature", ";", "links", ".", "resolvedSignature", "=", "anySignature", ";", "var", "type", "=", "checkExpression", "(", "iife", ".", "arguments", "[", "indexOfParameter", "]", ")", ";", "links", ".", "resolvedSignature", "=", "cached", ";", "return", "type", ";", "}", "}", "var", "contextualSignature", "=", "getContextualSignature", "(", "func", ")", ";", "if", "(", "contextualSignature", ")", "{", "var", "funcHasRestParameters", "=", "ts", ".", "hasRestParameter", "(", "func", ")", ";", "var", "len", "=", "func", ".", "parameters", ".", "length", "-", "(", "funcHasRestParameters", "?", "1", ":", "0", ")", ";", "var", "indexOfParameter", "=", "ts", ".", "indexOf", "(", "func", ".", "parameters", ",", "parameter", ")", ";", "if", "(", "indexOfParameter", "<", "len", ")", "{", "return", "getTypeAtPosition", "(", "contextualSignature", ",", "indexOfParameter", ")", ";", "}", "if", "(", "funcHasRestParameters", "&&", "indexOfParameter", "===", "(", "func", ".", "parameters", ".", "length", "-", "1", ")", "&&", "isRestParameterIndex", "(", "contextualSignature", ",", "func", ".", "parameters", ".", "length", "-", "1", ")", ")", "{", "return", "getTypeOfSymbol", "(", "ts", ".", "lastOrUndefined", "(", "contextualSignature", ".", "parameters", ")", ")", ";", "}", "}", "}", "return", "undefined", ";", "}" ]

[ "Return", "contextual", "type", "of", "parameter", "or", "undefined", "if", "no", "contextual", "type", "is", "available" ]

[ "function", "getContextualTypeForInitializerExpression", "(", "node", ")", "{", "var", "declaration", "=", "node", ".", "parent", ";", "if", "(", "node", "===", "declaration", ".", "initializer", ")", "{", "if", "(", "declaration", ".", "type", ")", "{", "return", "getTypeFromTypeNode", "(", "declaration", ".", "type", ")", ";", "}", "if", "(", "declaration", ".", "kind", "===", "142", ")", "{", "var", "type", "=", "getContextuallyTypedParameterType", "(", "declaration", ")", ";", "if", "(", "type", ")", "{", "return", "type", ";", "}", "}", "if", "(", "ts", ".", "isBindingPattern", "(", "declaration", ".", "name", ")", ")", "{", "return", "getTypeFromBindingPattern", "(", "declaration", ".", "name", ",", "true", ",", "false", ")", ";", "}", "if", "(", "ts", ".", "isBindingPattern", "(", "declaration", ".", "parent", ")", ")", "{", "var", "parentDeclaration", "=", "declaration", ".", "parent", ".", "parent", ";", "var", "name_12", "=", "declaration", ".", "propertyName", "||", "declaration", ".", "name", ";", "if", "(", "ts", ".", "isVariableLike", "(", "parentDeclaration", ")", "&&", "parentDeclaration", ".", "type", "&&", "!", "ts", ".", "isBindingPattern", "(", "name_12", ")", ")", "{", "var", "text", "=", "getTextOfPropertyName", "(", "name_12", ")", ";", "if", "(", "text", ")", "{", "return", "getTypeOfPropertyOfType", "(", "getTypeFromTypeNode", "(", "parentDeclaration", ".", "type", ")", ",", "text", ")", ";", "}", "}", "}", "}", "return", "undefined", ";", "}" ]

[ "In", "a", "variable", "parameter", "or", "property", "declaration", "with", "a", "type", "annotation", "the", "contextual", "type", "of", "an", "initializer", "expression", "is", "the", "type", "of", "the", "variable", "parameter", "or", "property", ".", "Otherwise", "in", "a", "parameter", "declaration", "of", "a", "contextually", "typed", "function", "expression", "the", "contextual", "type", "of", "an", "initializer", "expression", "is", "the", "contextual", "type", "of", "the", "parameter", ".", "Otherwise", "in", "a", "variable", "or", "parameter", "declaration", "with", "a", "binding", "pattern", "name", "the", "contextual", "type", "of", "an", "initializer", "expression", "is", "the", "type", "implied", "by", "the", "binding", "pattern", ".", "Otherwise", "in", "a", "binding", "pattern", "inside", "a", "variable", "or", "parameter", "declaration", "the", "contextual", "type", "of", "an", "initializer", "expression", "is", "the", "type", "annotation", "of", "the", "containing", "declaration", "if", "present", "." ]

[ "function", "getContextualTypeForArgument", "(", "callTarget", ",", "arg", ")", "{", "var", "args", "=", "getEffectiveCallArguments", "(", "callTarget", ")", ";", "var", "argIndex", "=", "ts", ".", "indexOf", "(", "args", ",", "arg", ")", ";", "if", "(", "argIndex", ">=", "0", ")", "{", "var", "signature", "=", "getResolvedOrAnySignature", "(", "callTarget", ")", ";", "return", "getTypeAtPosition", "(", "signature", ",", "argIndex", ")", ";", "}", "return", "undefined", ";", "}" ]

[ "In", "a", "typed", "function", "call", "an", "argument", "or", "substitution", "expression", "is", "contextually", "typed", "by", "the", "type", "of", "the", "corresponding", "parameter", "." ]

[ "function", "contextualTypeIsTupleLikeType", "(", "type", ")", "{", "return", "!", "!", "(", "type", ".", "flags", "&", "524288", "?", "ts", ".", "forEach", "(", "type", ".", "types", ",", "isTupleLikeType", ")", ":", "isTupleLikeType", "(", "type", ")", ")", ";", "}" ]

[ "Return", "true", "if", "the", "given", "contextual", "type", "is", "a", "tuple", "-", "like", "type" ]

[ "function", "getContextualSignature", "(", "node", ")", "{", "ts", ".", "Debug", ".", "assert", "(", "node", ".", "kind", "!==", "147", "||", "ts", ".", "isObjectLiteralMethod", "(", "node", ")", ")", ";", "var", "type", "=", "getContextualTypeForFunctionLikeDeclaration", "(", "node", ")", ";", "if", "(", "!", "type", ")", "{", "return", "undefined", ";", "}", "if", "(", "!", "(", "type", ".", "flags", "&", "524288", ")", ")", "{", "return", "getNonGenericSignature", "(", "type", ")", ";", "}", "var", "signatureList", ";", "var", "types", "=", "type", ".", "types", ";", "for", "(", "var", "_i", "=", "0", ",", "types_12", "=", "types", ";", "_i", "<", "types_12", ".", "length", ";", "_i", "++", ")", "{", "var", "current", "=", "types_12", "[", "_i", "]", ";", "var", "signature", "=", "getNonGenericSignature", "(", "current", ")", ";", "if", "(", "signature", ")", "{", "if", "(", "!", "signatureList", ")", "{", "signatureList", "=", "[", "signature", "]", ";", "}", "else", "if", "(", "!", "compareSignaturesIdentical", "(", "signatureList", "[", "0", "]", ",", "signature", ",", "false", ",", "true", ",", "true", ",", "compareTypesIdentical", ")", ")", "{", "return", "undefined", ";", "}", "else", "{", "signatureList", ".", "push", "(", "signature", ")", ";", "}", "}", "}", "var", "result", ";", "if", "(", "signatureList", ")", "{", "result", "=", "cloneSignature", "(", "signatureList", "[", "0", "]", ")", ";", "result", ".", "resolvedReturnType", "=", "undefined", ";", "result", ".", "unionSignatures", "=", "signatureList", ";", "}", "return", "result", ";", "}" ]

[ "Return", "the", "contextual", "signature", "for", "a", "given", "expression", "node", ".", "A", "contextual", "type", "provides", "a", "contextual", "signature", "if", "it", "has", "a", "single", "call", "signature", "and", "if", "that", "call", "signature", "is", "non", "-", "generic", ".", "If", "the", "contextual", "type", "is", "a", "union", "type", "get", "the", "signature", "from", "each", "type", "possible", "and", "if", "they", "are", "all", "identical", "ignoring", "their", "return", "type", "the", "result", "is", "same", "signature", "but", "with", "return", "type", "as", "union", "type", "of", "return", "types", "from", "these", "signatures" ]

[ "function", "isJsxIntrinsicIdentifier", "(", "tagName", ")", "{", "if", "(", "tagName", ".", "kind", "===", "172", "||", "tagName", ".", "kind", "===", "97", ")", "{", "return", "false", ";", "}", "else", "{", "return", "ts", ".", "isIntrinsicJsxName", "(", "tagName", ".", "text", ")", ";", "}", "}" ]

[ "Returns", "true", "iff", "React", "would", "emit", "this", "tag", "name", "as", "a", "string", "rather", "than", "an", "identifier", "or", "qualified", "name" ]

[ "function", "checkClassPropertyAccess", "(", "node", ",", "left", ",", "type", ",", "prop", ")", "{", "var", "flags", "=", "getDeclarationFlagsFromSymbol", "(", "prop", ")", ";", "var", "declaringClass", "=", "getDeclaredTypeOfSymbol", "(", "getParentOfSymbol", "(", "prop", ")", ")", ";", "var", "errorNode", "=", "node", ".", "kind", "===", "172", "||", "node", ".", "kind", "===", "218", "?", "node", ".", "name", ":", "node", ".", "right", ";", "if", "(", "left", ".", "kind", "===", "95", ")", "{", "if", "(", "languageVersion", "<", "2", "&&", "getDeclarationKindFromSymbol", "(", "prop", ")", "!==", "147", ")", "{", "error", "(", "errorNode", ",", "ts", ".", "Diagnostics", ".", "Only_public_and_protected_methods_of_the_base_class_are_accessible_via_the_super_keyword", ")", ";", "return", "false", ";", "}", "if", "(", "flags", "&", "128", ")", "{", "error", "(", "errorNode", ",", "ts", ".", "Diagnostics", ".", "Abstract_method_0_in_class_1_cannot_be_accessed_via_super_expression", ",", "symbolToString", "(", "prop", ")", ",", "typeToString", "(", "declaringClass", ")", ")", ";", "return", "false", ";", "}", "}", "if", "(", "!", "(", "flags", "&", "(", "8", "|", "16", ")", ")", ")", "{", "return", "true", ";", "}", "if", "(", "flags", "&", "8", ")", "{", "var", "declaringClassDeclaration", "=", "getClassLikeDeclarationOfSymbol", "(", "getParentOfSymbol", "(", "prop", ")", ")", ";", "if", "(", "!", "isNodeWithinClass", "(", "node", ",", "declaringClassDeclaration", ")", ")", "{", "error", "(", "errorNode", ",", "ts", ".", "Diagnostics", ".", "Property_0_is_private_and_only_accessible_within_class_1", ",", "symbolToString", "(", "prop", ")", ",", "typeToString", "(", "declaringClass", ")", ")", ";", "return", "false", ";", "}", "return", "true", ";", "}", "if", "(", "left", ".", "kind", "===", "95", ")", "{", "return", "true", ";", "}", "var", "enclosingClass", "=", "forEachEnclosingClass", "(", "node", ",", "function", "(", "enclosingDeclaration", ")", "{", "var", "enclosingClass", "=", "getDeclaredTypeOfSymbol", "(", "getSymbolOfNode", "(", "enclosingDeclaration", ")", ")", ";", "return", "hasBaseType", "(", "enclosingClass", ",", "declaringClass", ")", "?", "enclosingClass", ":", "undefined", ";", "}", ")", ";", "if", "(", "!", "enclosingClass", ")", "{", "error", "(", "errorNode", ",", "ts", ".", "Diagnostics", ".", "Property_0_is_protected_and_only_accessible_within_class_1_and_its_subclasses", ",", "symbolToString", "(", "prop", ")", ",", "typeToString", "(", "declaringClass", ")", ")", ";", "return", "false", ";", "}", "if", "(", "flags", "&", "32", ")", "{", "return", "true", ";", "}", "if", "(", "type", ".", "flags", "&", "268435456", ")", "{", "type", "=", "getConstraintOfTypeParameter", "(", "type", ")", ";", "}", "if", "(", "!", "(", "getTargetType", "(", "type", ")", ".", "flags", "&", "(", "32768", "|", "65536", ")", "&&", "hasBaseType", "(", "type", ",", "enclosingClass", ")", ")", ")", "{", "error", "(", "errorNode", ",", "ts", ".", "Diagnostics", ".", "Property_0_is_protected_and_only_accessible_through_an_instance_of_class_1", ",", "symbolToString", "(", "prop", ")", ",", "typeToString", "(", "enclosingClass", ")", ")", ";", "return", "false", ";", "}", "return", "true", ";", "}" ]

[ "Check", "whether", "the", "requested", "property", "access", "is", "valid", ".", "Returns", "true", "if", "node", "is", "a", "valid", "property", "access", "and", "false", "otherwise", "." ]

[ "function", "getForInVariableSymbol", "(", "node", ")", "{", "var", "initializer", "=", "node", ".", "initializer", ";", "if", "(", "initializer", ".", "kind", "===", "219", ")", "{", "var", "variable", "=", "initializer", ".", "declarations", "[", "0", "]", ";", "if", "(", "variable", "&&", "!", "ts", ".", "isBindingPattern", "(", "variable", ".", "name", ")", ")", "{", "return", "getSymbolOfNode", "(", "variable", ")", ";", "}", "}", "else", "if", "(", "initializer", ".", "kind", "===", "69", ")", "{", "return", "getResolvedSymbol", "(", "initializer", ")", ";", "}", "return", "undefined", ";", "}" ]

[ "Return", "the", "symbol", "of", "the", "for", "-", "in", "variable", "declared", "or", "referenced", "by", "the", "given", "for", "-", "in", "statement", "." ]

[ "function", "getSingleCallSignature", "(", "type", ")", "{", "if", "(", "type", ".", "flags", "&", "2588672", ")", "{", "var", "resolved", "=", "resolveStructuredTypeMembers", "(", "type", ")", ";", "if", "(", "resolved", ".", "callSignatures", ".", "length", "===", "1", "&&", "resolved", ".", "constructSignatures", ".", "length", "===", "0", "&&", "resolved", ".", "properties", ".", "length", "===", "0", "&&", "!", "resolved", ".", "stringIndexInfo", "&&", "!", "resolved", ".", "numberIndexInfo", ")", "{", "return", "resolved", ".", "callSignatures", "[", "0", "]", ";", "}", "}", "return", "undefined", ";", "}" ]

[ "If", "type", "has", "a", "single", "call", "signature", "and", "no", "other", "members", "return", "that", "signature", ".", "Otherwise", "return", "undefined", "." ]

[ "function", "getEffectiveDecoratorFirstArgumentType", "(", "node", ")", "{", "if", "(", "node", ".", "kind", "===", "221", ")", "{", "var", "classSymbol", "=", "getSymbolOfNode", "(", "node", ")", ";", "return", "getTypeOfSymbol", "(", "classSymbol", ")", ";", "}", "if", "(", "node", ".", "kind", "===", "142", ")", "{", "node", "=", "node", ".", "parent", ";", "if", "(", "node", ".", "kind", "===", "148", ")", "{", "var", "classSymbol", "=", "getSymbolOfNode", "(", "node", ")", ";", "return", "getTypeOfSymbol", "(", "classSymbol", ")", ";", "}", "}", "if", "(", "node", ".", "kind", "===", "145", "||", "node", ".", "kind", "===", "147", "||", "node", ".", "kind", "===", "149", "||", "node", ".", "kind", "===", "150", ")", "{", "return", "getParentTypeOfClassElement", "(", "node", ")", ";", "}", "ts", ".", "Debug", ".", "fail", "(", "\"Unsupported decorator target.\"", ")", ";", "return", "unknownType", ";", "}" ]

[ "Returns", "the", "effective", "type", "of", "the", "first", "argument", "to", "a", "decorator", ".", "If", "node", "is", "a", "class", "declaration", "or", "class", "expression", "the", "effective", "argument", "type", "is", "the", "type", "of", "the", "static", "side", "of", "the", "class", ".", "If", "node", "is", "a", "parameter", "declaration", "the", "effective", "argument", "type", "is", "either", "the", "type", "of", "the", "static", "or", "instance", "side", "of", "the", "class", "for", "the", "parameter", "s", "parent", "method", "depending", "on", "whether", "the", "method", "is", "declared", "static", ".", "For", "a", "constructor", "the", "type", "is", "always", "the", "type", "of", "the", "static", "side", "of", "the", "class", ".", "If", "node", "is", "a", "property", "method", "or", "accessor", "declaration", "the", "effective", "argument", "type", "is", "the", "type", "of", "the", "static", "or", "instance", "side", "of", "the", "parent", "class", "for", "class", "element", "depending", "on", "whether", "the", "element", "is", "declared", "static", "." ]

[ "function", "getEffectiveArgumentType", "(", "node", ",", "argIndex", ",", "arg", ")", "{", "if", "(", "node", ".", "kind", "===", "143", ")", "{", "return", "getEffectiveDecoratorArgumentType", "(", "node", ",", "argIndex", ")", ";", "}", "else", "if", "(", "argIndex", "===", "0", "&&", "node", ".", "kind", "===", "176", ")", "{", "return", "getGlobalTemplateStringsArrayType", "(", ")", ";", "}", "return", "undefined", ";", "}" ]

[ "Gets", "the", "effective", "argument", "type", "for", "an", "argument", "in", "a", "call", "expression", "." ]

[ "function", "getResolvedSignature", "(", "node", ",", "candidatesOutArray", ")", "{", "var", "links", "=", "getNodeLinks", "(", "node", ")", ";", "var", "cached", "=", "links", ".", "resolvedSignature", ";", "if", "(", "cached", "&&", "cached", "!==", "resolvingSignature", "&&", "!", "candidatesOutArray", ")", "{", "return", "cached", ";", "}", "links", ".", "resolvedSignature", "=", "resolvingSignature", ";", "var", "result", "=", "resolveSignature", "(", "node", ",", "candidatesOutArray", ")", ";", "links", ".", "resolvedSignature", "=", "flowLoopStart", "===", "flowLoopCount", "?", "result", ":", "cached", ";", "return", "result", ";", "}" ]

[ "candidatesOutArray", "is", "passed", "by", "signature", "help", "in", "the", "language", "service", "and", "collectCandidates", "must", "fill", "it", "up", "with", "the", "appropriate", "candidate", "signatures" ]

[ "function", "checkCallExpression", "(", "node", ")", "{", "checkGrammarTypeArguments", "(", "node", ",", "node", ".", "typeArguments", ")", "||", "checkGrammarArguments", "(", "node", ",", "node", ".", "arguments", ")", ";", "var", "signature", "=", "getResolvedSignature", "(", "node", ")", ";", "if", "(", "node", ".", "expression", ".", "kind", "===", "95", ")", "{", "return", "voidType", ";", "}", "if", "(", "node", ".", "kind", "===", "175", ")", "{", "var", "declaration", "=", "signature", ".", "declaration", ";", "if", "(", "declaration", "&&", "declaration", ".", "kind", "!==", "148", "&&", "declaration", ".", "kind", "!==", "152", "&&", "declaration", ".", "kind", "!==", "157", "&&", "!", "ts", ".", "isJSDocConstructSignature", "(", "declaration", ")", ")", "{", "var", "funcSymbol", "=", "node", ".", "expression", ".", "kind", "===", "69", "?", "getResolvedSymbol", "(", "node", ".", "expression", ")", ":", "checkExpression", "(", "node", ".", "expression", ")", ".", "symbol", ";", "if", "(", "funcSymbol", "&&", "funcSymbol", ".", "members", "&&", "(", "funcSymbol", ".", "flags", "&", "16", "||", "ts", ".", "isDeclarationOfFunctionExpression", "(", "funcSymbol", ")", ")", ")", "{", "return", "getInferredClassType", "(", "funcSymbol", ")", ";", "}", "else", "if", "(", "compilerOptions", ".", "noImplicitAny", ")", "{", "error", "(", "node", ",", "ts", ".", "Diagnostics", ".", "new_expression_whose_target_lacks_a_construct_signature_implicitly_has_an_any_type", ")", ";", "}", "return", "anyType", ";", "}", "}", "if", "(", "ts", ".", "isInJavaScriptFile", "(", "node", ")", "&&", "ts", ".", "isRequireCall", "(", "node", ",", "true", ")", ")", "{", "return", "resolveExternalModuleTypeByLiteral", "(", "node", ".", "arguments", "[", "0", "]", ")", ";", "}", "return", "getReturnTypeOfSignature", "(", "signature", ")", ";", "}" ]

[ "Syntactically", "and", "semantically", "checks", "a", "call", "or", "new", "expression", "." ]

[ "function", "maybeTypeOfKind", "(", "type", ",", "kind", ")", "{", "if", "(", "type", ".", "flags", "&", "kind", ")", "{", "return", "true", ";", "}", "if", "(", "type", ".", "flags", "&", "1572864", ")", "{", "var", "types", "=", "type", ".", "types", ";", "for", "(", "var", "_i", "=", "0", ",", "types_13", "=", "types", ";", "_i", "<", "types_13", ".", "length", ";", "_i", "++", ")", "{", "var", "t", "=", "types_13", "[", "_i", "]", ";", "if", "(", "maybeTypeOfKind", "(", "t", ",", "kind", ")", ")", "{", "return", "true", ";", "}", "}", "}", "return", "false", ";", "}" ]

[ "Return", "true", "if", "type", "might", "be", "of", "the", "given", "kind", ".", "A", "union", "or", "intersection", "type", "might", "be", "of", "a", "given", "kind", "if", "at", "least", "one", "constituent", "type", "is", "of", "the", "given", "kind", "." ]

[ "function", "isTypeOfKind", "(", "type", ",", "kind", ")", "{", "if", "(", "type", ".", "flags", "&", "kind", ")", "{", "return", "true", ";", "}", "if", "(", "type", ".", "flags", "&", "524288", ")", "{", "var", "types", "=", "type", ".", "types", ";", "for", "(", "var", "_i", "=", "0", ",", "types_14", "=", "types", ";", "_i", "<", "types_14", ".", "length", ";", "_i", "++", ")", "{", "var", "t", "=", "types_14", "[", "_i", "]", ";", "if", "(", "!", "isTypeOfKind", "(", "t", ",", "kind", ")", ")", "{", "return", "false", ";", "}", "}", "return", "true", ";", "}", "if", "(", "type", ".", "flags", "&", "1048576", ")", "{", "var", "types", "=", "type", ".", "types", ";", "for", "(", "var", "_a", "=", "0", ",", "types_15", "=", "types", ";", "_a", "<", "types_15", ".", "length", ";", "_a", "++", ")", "{", "var", "t", "=", "types_15", "[", "_a", "]", ";", "if", "(", "isTypeOfKind", "(", "t", ",", "kind", ")", ")", "{", "return", "true", ";", "}", "}", "}", "return", "false", ";", "}" ]

[ "Return", "true", "if", "type", "is", "of", "the", "given", "kind", ".", "A", "union", "type", "is", "of", "a", "given", "kind", "if", "all", "constituent", "types", "are", "of", "the", "given", "kind", ".", "An", "intersection", "type", "is", "of", "a", "given", "kind", "if", "at", "least", "one", "constituent", "type", "is", "of", "the", "given", "kind", "." ]

[ "function", "checkForDisallowedESSymbolOperand", "(", "operator", ")", "{", "var", "offendingSymbolOperand", "=", "maybeTypeOfKind", "(", "leftType", ",", "512", ")", "?", "left", ":", "maybeTypeOfKind", "(", "rightType", ",", "512", ")", "?", "right", ":", "undefined", ";", "if", "(", "offendingSymbolOperand", ")", "{", "error", "(", "offendingSymbolOperand", ",", "ts", ".", "Diagnostics", ".", "The_0_operator_cannot_be_applied_to_type_symbol", ",", "ts", ".", "tokenToString", "(", "operator", ")", ")", ";", "return", "false", ";", "}", "return", "true", ";", "}" ]

[ "Return", "true", "if", "there", "was", "no", "error", "false", "if", "there", "was", "an", "error", "." ]

[ "function", "checkTypeParameter", "(", "node", ")", "{", "if", "(", "node", ".", "expression", ")", "{", "grammarErrorOnFirstToken", "(", "node", ".", "expression", ",", "ts", ".", "Diagnostics", ".", "Type_expected", ")", ";", "}", "checkSourceElement", "(", "node", ".", "constraint", ")", ";", "getConstraintOfTypeParameter", "(", "getDeclaredTypeOfTypeParameter", "(", "getSymbolOfNode", "(", "node", ")", ")", ")", ";", "if", "(", "produceDiagnostics", ")", "{", "checkTypeNameIsReserved", "(", "node", ".", "name", ",", "ts", ".", "Diagnostics", ".", "Type_parameter_name_cannot_be_0", ")", ";", "}", "}" ]

[ "DECLARATION", "AND", "STATEMENT", "TYPE", "CHECKING" ]

[ "function", "getPromisedType", "(", "promise", ")", "{", "if", "(", "isTypeAny", "(", "promise", ")", ")", "{", "return", "undefined", ";", "}", "if", "(", "promise", ".", "flags", "&", "131072", ")", "{", "if", "(", "promise", ".", "target", "===", "tryGetGlobalPromiseType", "(", ")", "||", "promise", ".", "target", "===", "getGlobalPromiseLikeType", "(", ")", ")", "{", "return", "promise", ".", "typeArguments", "[", "0", "]", ";", "}", "}", "var", "globalPromiseLikeType", "=", "getInstantiatedGlobalPromiseLikeType", "(", ")", ";", "if", "(", "globalPromiseLikeType", "===", "emptyObjectType", "||", "!", "isTypeAssignableTo", "(", "promise", ",", "globalPromiseLikeType", ")", ")", "{", "return", "undefined", ";", "}", "var", "thenFunction", "=", "getTypeOfPropertyOfType", "(", "promise", ",", "\"then\"", ")", ";", "if", "(", "!", "thenFunction", "||", "isTypeAny", "(", "thenFunction", ")", ")", "{", "return", "undefined", ";", "}", "var", "thenSignatures", "=", "getSignaturesOfType", "(", "thenFunction", ",", "0", ")", ";", "if", "(", "thenSignatures", ".", "length", "===", "0", ")", "{", "return", "undefined", ";", "}", "var", "onfulfilledParameterType", "=", "getTypeWithFacts", "(", "getUnionType", "(", "ts", ".", "map", "(", "thenSignatures", ",", "getTypeOfFirstParameterOfSignature", ")", ")", ",", "131072", ")", ";", "if", "(", "isTypeAny", "(", "onfulfilledParameterType", ")", ")", "{", "return", "undefined", ";", "}", "var", "onfulfilledParameterSignatures", "=", "getSignaturesOfType", "(", "onfulfilledParameterType", ",", "0", ")", ";", "if", "(", "onfulfilledParameterSignatures", ".", "length", "===", "0", ")", "{", "return", "undefined", ";", "}", "return", "getUnionType", "(", "ts", ".", "map", "(", "onfulfilledParameterSignatures", ",", "getTypeOfFirstParameterOfSignature", ")", ",", "true", ")", ";", "}" ]

[ "Gets", "the", "promised", "type", "of", "a", "promise", "." ]

[ "function", "checkAsyncFunctionReturnType", "(", "node", ")", "{", "if", "(", "languageVersion", ">=", "2", ")", "{", "var", "returnType", "=", "getTypeFromTypeNode", "(", "node", ".", "type", ")", ";", "return", "checkCorrectPromiseType", "(", "returnType", ",", "node", ".", "type", ")", ";", "}", "var", "globalPromiseConstructorLikeType", "=", "getGlobalPromiseConstructorLikeType", "(", ")", ";", "if", "(", "globalPromiseConstructorLikeType", "===", "emptyObjectType", ")", "{", "return", "unknownType", ";", "}", "var", "promiseType", "=", "getTypeFromTypeNode", "(", "node", ".", "type", ")", ";", "if", "(", "promiseType", "===", "unknownType", "&&", "compilerOptions", ".", "isolatedModules", ")", "{", "return", "unknownType", ";", "}", "var", "promiseConstructor", "=", "getNodeLinks", "(", "node", ".", "type", ")", ".", "resolvedSymbol", ";", "if", "(", "!", "promiseConstructor", "||", "!", "symbolIsValue", "(", "promiseConstructor", ")", ")", "{", "var", "typeName", "=", "promiseConstructor", "?", "symbolToString", "(", "promiseConstructor", ")", ":", "typeToString", "(", "promiseType", ")", ";", "error", "(", "node", ",", "ts", ".", "Diagnostics", ".", "Type_0_is_not_a_valid_async_function_return_type", ",", "typeName", ")", ";", "return", "unknownType", ";", "}", "checkReturnTypeAnnotationAsExpression", "(", "node", ")", ";", "var", "promiseConstructorType", "=", "getTypeOfSymbol", "(", "promiseConstructor", ")", ";", "if", "(", "!", "checkTypeAssignableTo", "(", "promiseConstructorType", ",", "globalPromiseConstructorLikeType", ",", "node", ",", "ts", ".", "Diagnostics", ".", "Type_0_is_not_a_valid_async_function_return_type", ")", ")", "{", "return", "unknownType", ";", "}", "var", "promiseName", "=", "ts", ".", "getEntityNameFromTypeNode", "(", "node", ".", "type", ")", ";", "var", "promiseNameOrNamespaceRoot", "=", "getFirstIdentifier", "(", "promiseName", ")", ";", "var", "rootSymbol", "=", "getSymbol", "(", "node", ".", "locals", ",", "promiseNameOrNamespaceRoot", ".", "text", ",", "107455", ")", ";", "if", "(", "rootSymbol", ")", "{", "error", "(", "rootSymbol", ".", "valueDeclaration", ",", "ts", ".", "Diagnostics", ".", "Duplicate_identifier_0_Compiler_uses_declaration_1_to_support_async_functions", ",", "promiseNameOrNamespaceRoot", ".", "text", ",", "getFullyQualifiedName", "(", "promiseConstructor", ")", ")", ";", "return", "unknownType", ";", "}", "return", "checkAwaitedType", "(", "promiseType", ",", "node", ",", "ts", ".", "Diagnostics", ".", "An_async_function_or_method_must_have_a_valid_awaitable_return_type", ")", ";", "}" ]

[ "Checks", "the", "return", "type", "of", "an", "async", "function", "to", "ensure", "it", "is", "a", "compatible", "Promise", "implementation", "." ]

[ "function", "checkDecorators", "(", "node", ")", "{", "if", "(", "!", "node", ".", "decorators", ")", "{", "return", ";", "}", "if", "(", "!", "ts", ".", "nodeCanBeDecorated", "(", "node", ")", ")", "{", "return", ";", "}", "if", "(", "!", "compilerOptions", ".", "experimentalDecorators", ")", "{", "error", "(", "node", ",", "ts", ".", "Diagnostics", ".", "Experimental_support_for_decorators_is_a_feature_that_is_subject_to_change_in_a_future_release_Set_the_experimentalDecorators_option_to_remove_this_warning", ")", ";", "}", "if", "(", "compilerOptions", ".", "emitDecoratorMetadata", ")", "{", "switch", "(", "node", ".", "kind", ")", "{", "case", "221", ":", "var", "constructor", "=", "ts", ".", "getFirstConstructorWithBody", "(", "node", ")", ";", "if", "(", "constructor", ")", "{", "checkParameterTypeAnnotationsAsExpressions", "(", "constructor", ")", ";", "}", "break", ";", "case", "147", ":", "case", "149", ":", "case", "150", ":", "checkParameterTypeAnnotationsAsExpressions", "(", "node", ")", ";", "checkReturnTypeAnnotationAsExpression", "(", "node", ")", ";", "break", ";", "case", "145", ":", "case", "142", ":", "checkTypeAnnotationAsExpression", "(", "node", ")", ";", "break", ";", "}", "}", "ts", ".", "forEach", "(", "node", ".", "decorators", ",", "checkDecorator", ")", ";", "}" ]

[ "Check", "the", "decorators", "of", "a", "node" ]

[ "function", "checkParameterInitializer", "(", "node", ")", "{", "if", "(", "ts", ".", "getRootDeclaration", "(", "node", ")", ".", "kind", "!==", "142", ")", "{", "return", ";", "}", "var", "func", "=", "ts", ".", "getContainingFunction", "(", "node", ")", ";", "visit", "(", "node", ".", "initializer", ")", ";", "function", "visit", "(", "n", ")", "{", "if", "(", "ts", ".", "isTypeNode", "(", "n", ")", "||", "ts", ".", "isDeclarationName", "(", "n", ")", ")", "{", "return", ";", "}", "if", "(", "n", ".", "kind", "===", "172", ")", "{", "return", "visit", "(", "n", ".", "expression", ")", ";", "}", "else", "if", "(", "n", ".", "kind", "===", "69", ")", "{", "var", "symbol", "=", "resolveName", "(", "n", ",", "n", ".", "text", ",", "107455", "|", "8388608", ",", "undefined", ",", "undefined", ")", ";", "if", "(", "!", "symbol", "||", "symbol", "===", "unknownSymbol", "||", "!", "symbol", ".", "valueDeclaration", ")", "{", "return", ";", "}", "if", "(", "symbol", ".", "valueDeclaration", "===", "node", ")", "{", "error", "(", "n", ",", "ts", ".", "Diagnostics", ".", "Parameter_0_cannot_be_referenced_in_its_initializer", ",", "ts", ".", "declarationNameToString", "(", "node", ".", "name", ")", ")", ";", "return", ";", "}", "var", "enclosingContainer", "=", "ts", ".", "getEnclosingBlockScopeContainer", "(", "symbol", ".", "valueDeclaration", ")", ";", "if", "(", "enclosingContainer", "===", "func", ")", "{", "if", "(", "symbol", ".", "valueDeclaration", ".", "kind", "===", "142", ")", "{", "if", "(", "symbol", ".", "valueDeclaration", ".", "pos", "<", "node", ".", "pos", ")", "{", "return", ";", "}", "var", "current", "=", "n", ";", "while", "(", "current", "!==", "node", ".", "initializer", ")", "{", "if", "(", "ts", ".", "isFunctionLike", "(", "current", ".", "parent", ")", ")", "{", "return", ";", "}", "if", "(", "current", ".", "parent", ".", "kind", "===", "145", "&&", "!", "(", "current", ".", "parent", ".", "flags", "&", "32", ")", "&&", "ts", ".", "isClassLike", "(", "current", ".", "parent", ".", "parent", ")", ")", "{", "return", ";", "}", "current", "=", "current", ".", "parent", ";", "}", "}", "error", "(", "n", ",", "ts", ".", "Diagnostics", ".", "Initializer_of_parameter_0_cannot_reference_identifier_1_declared_after_it", ",", "ts", ".", "declarationNameToString", "(", "node", ".", "name", ")", ",", "ts", ".", "declarationNameToString", "(", "n", ")", ")", ";", "}", "}", "else", "{", "return", "ts", ".", "forEachChild", "(", "n", ",", "visit", ")", ";", "}", "}", "}" ]

[ "Check", "that", "a", "parameter", "initializer", "contains", "no", "references", "to", "parameters", "declared", "to", "the", "right", "of", "itself" ]

[ "function", "checkTypeParameterListsIdentical", "(", "node", ",", "symbol", ")", "{", "if", "(", "symbol", ".", "declarations", ".", "length", "===", "1", ")", "{", "return", ";", "}", "var", "firstDecl", ";", "for", "(", "var", "_i", "=", "0", ",", "_a", "=", "symbol", ".", "declarations", ";", "_i", "<", "_a", ".", "length", ";", "_i", "++", ")", "{", "var", "declaration", "=", "_a", "[", "_i", "]", ";", "if", "(", "declaration", ".", "kind", "===", "221", "||", "declaration", ".", "kind", "===", "222", ")", "{", "if", "(", "!", "firstDecl", ")", "{", "firstDecl", "=", "declaration", ";", "}", "else", "if", "(", "!", "areTypeParametersIdentical", "(", "firstDecl", ".", "typeParameters", ",", "node", ".", "typeParameters", ")", ")", "{", "error", "(", "node", ".", "name", ",", "ts", ".", "Diagnostics", ".", "All_declarations_of_0_must_have_identical_type_parameters", ",", "node", ".", "name", ".", "text", ")", ";", "}", "}", "}", "}" ]

[ "Check", "that", "type", "parameter", "lists", "are", "identical", "across", "multiple", "declarations" ]

[ "function", "checkSourceFileWorker", "(", "node", ")", "{", "var", "links", "=", "getNodeLinks", "(", "node", ")", ";", "if", "(", "!", "(", "links", ".", "flags", "&", "1", ")", ")", "{", "if", "(", "compilerOptions", ".", "skipLibCheck", "&&", "node", ".", "isDeclarationFile", "||", "compilerOptions", ".", "skipDefaultLibCheck", "&&", "node", ".", "hasNoDefaultLib", ")", "{", "return", ";", "}", "checkGrammarSourceFile", "(", "node", ")", ";", "potentialThisCollisions", ".", "length", "=", "0", ";", "deferredNodes", "=", "[", "]", ";", "deferredUnusedIdentifierNodes", "=", "produceDiagnostics", "&&", "noUnusedIdentifiers", "?", "[", "]", ":", "undefined", ";", "ts", ".", "forEach", "(", "node", ".", "statements", ",", "checkSourceElement", ")", ";", "checkDeferredNodes", "(", ")", ";", "if", "(", "ts", ".", "isExternalModule", "(", "node", ")", ")", "{", "registerForUnusedIdentifiersCheck", "(", "node", ")", ";", "}", "if", "(", "!", "node", ".", "isDeclarationFile", ")", "{", "checkUnusedIdentifiers", "(", ")", ";", "}", "deferredNodes", "=", "undefined", ";", "deferredUnusedIdentifierNodes", "=", "undefined", ";", "if", "(", "ts", ".", "isExternalOrCommonJsModule", "(", "node", ")", ")", "{", "checkExternalModuleExports", "(", "node", ")", ";", "}", "if", "(", "potentialThisCollisions", ".", "length", ")", "{", "ts", ".", "forEach", "(", "potentialThisCollisions", ",", "checkIfThisIsCapturedInEnclosingScope", ")", ";", "potentialThisCollisions", ".", "length", "=", "0", ";", "}", "links", ".", "flags", "|=", "1", ";", "}", "}" ]

[ "Fully", "type", "check", "a", "source", "file", "and", "collect", "the", "relevant", "diagnostics", "." ]

[ "function", "isInsideWithStatementBody", "(", "node", ")", "{", "if", "(", "node", ")", "{", "while", "(", "node", ".", "parent", ")", "{", "if", "(", "node", ".", "parent", ".", "kind", "===", "212", "&&", "node", ".", "parent", ".", "statement", "===", "node", ")", "{", "return", "true", ";", "}", "node", "=", "node", ".", "parent", ";", "}", "}", "return", "false", ";", "}" ]

[ "Language", "service", "support" ]

[ "function", "copySymbol", "(", "symbol", ",", "meaning", ")", "{", "if", "(", "symbol", ".", "flags", "&", "meaning", ")", "{", "var", "id", "=", "symbol", ".", "name", ";", "if", "(", "!", "symbols", "[", "id", "]", ")", "{", "symbols", "[", "id", "]", "=", "symbol", ";", "}", "}", "}" ]

[ "Copy", "the", "given", "symbol", "into", "symbol", "tables", "if", "the", "symbol", "has", "the", "given", "meaning", "and", "it", "doesn", "t", "already", "existed", "in", "the", "symbol", "table" ]

[ "function", "isTypeReferenceIdentifier", "(", "entityName", ")", "{", "var", "node", "=", "entityName", ";", "while", "(", "node", ".", "parent", "&&", "node", ".", "parent", ".", "kind", "===", "139", ")", "{", "node", "=", "node", ".", "parent", ";", "}", "return", "node", ".", "parent", "&&", "(", "node", ".", "parent", ".", "kind", "===", "155", "||", "node", ".", "parent", ".", "kind", "===", "267", ")", ";", "}" ]

[ "True", "if", "the", "given", "identifier", "is", "part", "of", "a", "type", "reference" ]

[ "function", "getExportSpecifierLocalTargetSymbol", "(", "node", ")", "{", "return", "node", ".", "parent", ".", "parent", ".", "moduleSpecifier", "?", "getExternalModuleMember", "(", "node", ".", "parent", ".", "parent", ",", "node", ")", ":", "resolveEntityName", "(", "node", ".", "propertyName", "||", "node", ".", "name", ",", "107455", "|", "793064", "|", "1920", "|", "8388608", ")", ";", "}" ]

[ "Returns", "the", "target", "of", "an", "export", "specifier", "without", "following", "aliases" ]

[ "function", "getReferencedDeclarationWithCollidingName", "(", "node", ")", "{", "var", "symbol", "=", "getReferencedValueSymbol", "(", "node", ")", ";", "return", "symbol", "&&", "isSymbolOfDeclarationWithCollidingName", "(", "symbol", ")", "?", "symbol", ".", "valueDeclaration", ":", "undefined", ";", "}" ]

[ "When", "resolved", "as", "an", "expression", "identifier", "if", "the", "given", "node", "references", "a", "nested", "block", "scoped", "entity", "with", "a", "name", "that", "either", "hides", "an", "existing", "name", "or", "might", "hide", "it", "when", "compiled", "downlevel", "return", "the", "declaration", "of", "that", "entity", ".", "Otherwise", "return", "undefined", "." ]

[ "function", "encodeLastRecordedSourceMapSpan", "(", ")", "{", "if", "(", "!", "lastRecordedSourceMapSpan", "||", "lastRecordedSourceMapSpan", "===", "lastEncodedSourceMapSpan", ")", "{", "return", ";", "}", "var", "prevEncodedEmittedColumn", "=", "lastEncodedSourceMapSpan", ".", "emittedColumn", ";", "if", "(", "lastEncodedSourceMapSpan", ".", "emittedLine", "===", "lastRecordedSourceMapSpan", ".", "emittedLine", ")", "{", "if", "(", "sourceMapData", ".", "sourceMapMappings", ")", "{", "sourceMapData", ".", "sourceMapMappings", "+=", "\",\"", ";", "}", "}", "else", "{", "for", "(", "var", "encodedLine", "=", "lastEncodedSourceMapSpan", ".", "emittedLine", ";", "encodedLine", "<", "lastRecordedSourceMapSpan", ".", "emittedLine", ";", "encodedLine", "++", ")", "{", "sourceMapData", ".", "sourceMapMappings", "+=", "\";\"", ";", "}", "prevEncodedEmittedColumn", "=", "1", ";", "}", "sourceMapData", ".", "sourceMapMappings", "+=", "base64VLQFormatEncode", "(", "lastRecordedSourceMapSpan", ".", "emittedColumn", "-", "prevEncodedEmittedColumn", ")", ";", "sourceMapData", ".", "sourceMapMappings", "+=", "base64VLQFormatEncode", "(", "lastRecordedSourceMapSpan", ".", "sourceIndex", "-", "lastEncodedSourceMapSpan", ".", "sourceIndex", ")", ";", "sourceMapData", ".", "sourceMapMappings", "+=", "base64VLQFormatEncode", "(", "lastRecordedSourceMapSpan", ".", "sourceLine", "-", "lastEncodedSourceMapSpan", ".", "sourceLine", ")", ";", "sourceMapData", ".", "sourceMapMappings", "+=", "base64VLQFormatEncode", "(", "lastRecordedSourceMapSpan", ".", "sourceColumn", "-", "lastEncodedSourceMapSpan", ".", "sourceColumn", ")", ";", "if", "(", "lastRecordedSourceMapSpan", ".", "nameIndex", ">=", "0", ")", "{", "ts", ".", "Debug", ".", "assert", "(", "false", ",", "\"We do not support name index right now, Make sure to update updateLastEncodedAndRecordedSpans when we start using this\"", ")", ";", "sourceMapData", ".", "sourceMapMappings", "+=", "base64VLQFormatEncode", "(", "lastRecordedSourceMapSpan", ".", "nameIndex", "-", "lastEncodedNameIndex", ")", ";", "lastEncodedNameIndex", "=", "lastRecordedSourceMapSpan", ".", "nameIndex", ";", "}", "lastEncodedSourceMapSpan", "=", "lastRecordedSourceMapSpan", ";", "sourceMapData", ".", "sourceMapDecodedMappings", ".", "push", "(", "lastEncodedSourceMapSpan", ")", ";", "}" ]

[ "Encoding", "for", "sourcemap", "span" ]

[ "function", "getExportDefaultTempVariableName", "(", ")", "{", "var", "baseName", "=", "\"_default\"", ";", "if", "(", "!", "(", "baseName", "in", "currentIdentifiers", ")", ")", "{", "return", "baseName", ";", "}", "var", "count", "=", "0", ";", "while", "(", "true", ")", "{", "count", "++", ";", "var", "name_23", "=", "baseName", "+", "\"_\"", "+", "count", ";", "if", "(", "!", "(", "name_23", "in", "currentIdentifiers", ")", ")", "{", "return", "name_23", ";", "}", "}", "}" ]

[ "Return", "a", "temp", "variable", "name", "to", "be", "used", "in", "export", "default", "statements", ".", "The", "temp", "name", "will", "be", "of", "the", "form", "_default_counter", ".", "Note", "that", "export", "default", "is", "only", "allowed", "at", "most", "once", "in", "a", "module", "so", "we", "do", "not", "need", "to", "keep", "track", "of", "created", "temp", "names", "." ]

[ "function", "writeReferencePath", "(", "referencedFile", ",", "addBundledFileReference", ",", "emitOnlyDtsFiles", ")", "{", "var", "declFileName", ";", "var", "addedBundledEmitReference", "=", "false", ";", "if", "(", "ts", ".", "isDeclarationFile", "(", "referencedFile", ")", ")", "{", "declFileName", "=", "referencedFile", ".", "fileName", ";", "}", "else", "{", "ts", ".", "forEachExpectedEmitFile", "(", "host", ",", "getDeclFileName", ",", "referencedFile", ",", "emitOnlyDtsFiles", ")", ";", "}", "if", "(", "declFileName", ")", "{", "declFileName", "=", "ts", ".", "getRelativePathToDirectoryOrUrl", "(", "ts", ".", "getDirectoryPath", "(", "ts", ".", "normalizeSlashes", "(", "declarationFilePath", ")", ")", ",", "declFileName", ",", "host", ".", "getCurrentDirectory", "(", ")", ",", "host", ".", "getCanonicalFileName", ",", "false", ")", ";", "referencesOutput", "+=", "\"/// <reference path=\\\"\"", "+", "\\\"", "+", "declFileName", "+", "\"\\\" />\"", ";", "}", "\\\"", "newLine", "}" ]

[ "Adds", "the", "reference", "to", "referenced", "file", "returns", "true", "if", "global", "file", "reference", "was", "emitted" ]

[ "function", "emitFiles", "(", "resolver", ",", "host", ",", "targetSourceFile", ",", "emitOnlyDtsFiles", ")", "{", "var", "extendsHelper", "=", "\"\\nvar __extends = (this && this.__extends) || function (d, b) {\\n for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\\n function __() { this.constructor = d; }\\n d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\\n};\"", ";", "\\n", "\\n", "\\n", "\\n", "\\n", "var", "assignHelper", "=", "\"\\nvar __assign = (this && this.__assign) || Object.assign || function(t) {\\n for (var s, i = 1, n = arguments.length; i < n; i++) {\\n s = arguments[i];\\n for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))\\n t[p] = s[p];\\n }\\n return t;\\n};\"", ";", "\\n", "\\n", "\\n", "\\n", "\\n", "\\n", "\\n", "\\n", "var", "decorateHelper", "=", "\"\\nvar __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {\\n var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\\n if (typeof Reflect === \\\"object\\\" && typeof Reflect.decorate === \\\"function\\\") r = Reflect.decorate(decorators, target, key, desc);\\n else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\\n return c > 3 && r && Object.defineProperty(target, key, r), r;\\n};\"", ";", "\\n", "\\n", "\\n", "\\\"", "\\\"", "\\\"", "}" ]

[ "targetSourceFile", "is", "when", "users", "only", "want", "one", "file", "in", "entire", "project", "to", "be", "emitted", ".", "This", "is", "used", "in", "compileOnSave", "feature" ]

[ "function", "makeTempVariableName", "(", "flags", ")", "{", "if", "(", "flags", "&&", "!", "(", "tempFlags", "&", "flags", ")", ")", "{", "var", "name_24", "=", "flags", "===", "268435456", "?", "\"_i\"", ":", "\"_n\"", ";", "if", "(", "isUniqueName", "(", "name_24", ")", ")", "{", "tempFlags", "|=", "flags", ";", "return", "name_24", ";", "}", "}", "while", "(", "true", ")", "{", "var", "count", "=", "tempFlags", "&", "268435455", ";", "tempFlags", "++", ";", "if", "(", "count", "!==", "8", "&&", "count", "!==", "13", ")", "{", "var", "name_25", "=", "count", "<", "26", "?", "\"_\"", "+", "String", ".", "fromCharCode", "(", "97", "+", "count", ")", ":", "\"_\"", "+", "(", "count", "-", "26", ")", ";", "if", "(", "isUniqueName", "(", "name_25", ")", ")", "{", "return", "name_25", ";", "}", "}", "}", "}" ]

[ "Return", "the", "next", "available", "name", "in", "the", "pattern", "_a", "...", "_z", "_0", "_1", "...", "TempFlags", ".", "_i", "or", "TempFlags", ".", "_n", "may", "be", "used", "to", "express", "a", "preference", "for", "that", "dedicated", "name", ".", "Note", "that", "names", "generated", "by", "makeTempVariableName", "and", "makeUniqueName", "will", "never", "conflict", "." ]

[ "function", "writeEmittedFiles", "(", "emitOutput", ",", "jsFilePath", ",", "sourceMapFilePath", ",", "writeByteOrderMark", ",", "sourceFiles", ")", "{", "if", "(", "compilerOptions", ".", "sourceMap", "&&", "!", "compilerOptions", ".", "inlineSourceMap", ")", "{", "ts", ".", "writeFile", "(", "host", ",", "emitterDiagnostics", ",", "sourceMapFilePath", ",", "sourceMap", ".", "getText", "(", ")", ",", "false", ",", "sourceFiles", ")", ";", "}", "if", "(", "sourceMapDataList", ")", "{", "sourceMapDataList", ".", "push", "(", "sourceMap", ".", "getSourceMapData", "(", ")", ")", ";", "}", "ts", ".", "writeFile", "(", "host", ",", "emitterDiagnostics", ",", "jsFilePath", ",", "emitOutput", ",", "writeByteOrderMark", ",", "sourceFiles", ")", ";", "}" ]

[ "Write", "emitted", "output", "to", "disk" ]

[ "function", "emitToken", "(", "tokenKind", ",", "startPos", ",", "emitFn", ")", "{", "var", "tokenStartPos", "=", "ts", ".", "skipTrivia", "(", "currentText", ",", "startPos", ")", ";", "emitPos", "(", "tokenStartPos", ")", ";", "var", "tokenString", "=", "ts", ".", "tokenToString", "(", "tokenKind", ")", ";", "if", "(", "emitFn", ")", "{", "emitFn", "(", ")", ";", "}", "else", "{", "write", "(", "tokenString", ")", ";", "}", "var", "tokenEndPos", "=", "tokenStartPos", "+", "tokenString", ".", "length", ";", "emitPos", "(", "tokenEndPos", ")", ";", "return", "tokenEndPos", ";", "}" ]

[ "Emit", "the", "text", "for", "the", "given", "token", "that", "comes", "after", "startPos", "This", "by", "default", "writes", "the", "text", "provided", "with", "the", "given", "tokenKind", "but", "if", "optional", "emitFn", "callback", "is", "provided", "the", "text", "is", "emitted", "using", "the", "callback", "instead", "of", "default", "text" ]

[ "function", "isImportedReference", "(", "node", ")", "{", "var", "declaration", "=", "resolver", ".", "getReferencedImportDeclaration", "(", "node", ")", ";", "return", "declaration", "&&", "(", "declaration", ".", "kind", "===", "231", "||", "declaration", ".", "kind", "===", "234", ")", ";", "}" ]

[ "Return", "true", "if", "identifier", "resolves", "to", "an", "imported", "identifier" ]

[ "function", "tryEmitStartOfVariableDeclarationList", "(", "decl", ")", "{", "if", "(", "shouldHoistVariable", "(", "decl", ",", "true", ")", ")", "{", "return", "false", ";", "}", "if", "(", "convertedLoopState", "&&", "(", "ts", ".", "getCombinedNodeFlags", "(", "decl", ")", "&", "3072", ")", "===", "0", ")", "{", "for", "(", "var", "_a", "=", "0", ",", "_b", "=", "decl", ".", "declarations", ";", "_a", "<", "_b", ".", "length", ";", "_a", "++", ")", "{", "var", "varDecl", "=", "_b", "[", "_a", "]", ";", "hoistVariableDeclarationFromLoop", "(", "convertedLoopState", ",", "varDecl", ")", ";", "}", "return", "false", ";", "}", "emitStart", "(", "decl", ")", ";", "if", "(", "decl", "&&", "languageVersion", ">=", "2", ")", "{", "if", "(", "ts", ".", "isLet", "(", "decl", ")", ")", "{", "write", "(", "\"let \"", ")", ";", "}", "else", "if", "(", "ts", ".", "isConst", "(", "decl", ")", ")", "{", "write", "(", "\"const \"", ")", ";", "}", "else", "{", "write", "(", "\"var \"", ")", ";", "}", "}", "else", "{", "write", "(", "\"var \"", ")", ";", "}", "return", "true", ";", "}" ]

[ "Returns", "true", "if", "start", "of", "variable", "declaration", "list", "was", "emitted", ".", "Returns", "false", "if", "nothing", "was", "written", "-", "this", "can", "happen", "for", "source", "file", "level", "variable", "declarations", "in", "system", "modules", "where", "such", "variable", "declarations", "are", "hoisted", "." ]

[ "function", "emitAssignment", "(", "name", ",", "value", ",", "shouldEmitCommaBeforeAssignment", ",", "nodeForSourceMap", ")", "{", "if", "(", "shouldEmitCommaBeforeAssignment", ")", "{", "write", "(", "\", \"", ")", ";", "}", "var", "exportChanged", "=", "isNameOfExportedSourceLevelDeclarationInSystemExternalModule", "(", "name", ")", ";", "if", "(", "exportChanged", ")", "{", "write", "(", "exportFunctionForFile", "+", "\"(\\\"\"", ")", ";", "\\\"", "emitNodeWithCommentsAndWithoutSourcemap", "(", "name", ")", ";", "}", "write", "(", "\"\\\", \"", ")", ";", "\\\"", "var", "isVariableDeclarationOrBindingElement", "=", "name", ".", "parent", "&&", "(", "name", ".", "parent", ".", "kind", "===", "218", "||", "name", ".", "parent", ".", "kind", "===", "169", ")", ";", "emitStart", "(", "isFirstVariableDeclaration", "(", "nodeForSourceMap", ")", "?", "nodeForSourceMap", ".", "parent", ":", "nodeForSourceMap", ")", ";", "withTemporaryNoSourceMap", "(", "function", "(", ")", "{", "if", "(", "isVariableDeclarationOrBindingElement", ")", "{", "emitModuleMemberName", "(", "name", ".", "parent", ")", ";", "}", "else", "{", "emit", "(", "name", ")", ";", "}", "write", "(", "\" = \"", ")", ";", "emit", "(", "value", ")", ";", "}", ")", ";", "}" ]

[ "Emit", "an", "assignment", "to", "a", "given", "identifier", "name", "with", "a", "given", "expression", "value", "." ]

[ "function", "getSuperCallAtGivenIndex", "(", "ctor", ",", "index", ")", "{", "if", "(", "!", "ctor", ".", "body", ")", "{", "return", "undefined", ";", "}", "var", "statements", "=", "ctor", ".", "body", ".", "statements", ";", "if", "(", "!", "statements", "||", "index", ">=", "statements", ".", "length", ")", "{", "return", "undefined", ";", "}", "var", "statement", "=", "statements", "[", "index", "]", ";", "if", "(", "statement", ".", "kind", "===", "202", ")", "{", "return", "ts", ".", "isSuperCallExpression", "(", "statement", ".", "expression", ")", "?", "statement", ":", "undefined", ";", "}", "}" ]

[ "Return", "the", "statement", "at", "a", "given", "index", "if", "it", "is", "a", "super", "-", "call", "statement" ]

[ "function", "isTripleSlashComment", "(", "comment", ")", "{", "if", "(", "currentText", ".", "charCodeAt", "(", "comment", ".", "pos", "+", "1", ")", "===", "47", "&&", "comment", ".", "pos", "+", "2", "<", "comment", ".", "end", "&&", "currentText", ".", "charCodeAt", "(", "comment", ".", "pos", "+", "2", ")", "===", "47", ")", "{", "var", "textSubStr", "=", "currentText", ".", "substring", "(", "comment", ".", "pos", ",", "comment", ".", "end", ")", ";", "return", "textSubStr", ".", "match", "(", "ts", ".", "fullTripleSlashReferencePathRegEx", ")", "||", "textSubStr", ".", "match", "(", "ts", ".", "fullTripleSlashAMDReferencePathRegEx", ")", "?", "true", ":", "false", ";", "}", "return", "false", ";", "}" ]

[ "Determine", "if", "the", "given", "comment", "is", "a", "triple", "-", "slash" ]

[ "function", "getAutomaticTypeDirectiveNames", "(", "options", ",", "host", ")", "{", "if", "(", "options", ".", "types", ")", "{", "return", "options", ".", "types", ";", "}", "var", "result", "=", "[", "]", ";", "if", "(", "host", ".", "directoryExists", "&&", "host", ".", "getDirectories", ")", "{", "var", "typeRoots", "=", "getEffectiveTypeRoots", "(", "options", ",", "host", ")", ";", "if", "(", "typeRoots", ")", "{", "for", "(", "var", "_i", "=", "0", ",", "typeRoots_1", "=", "typeRoots", ";", "_i", "<", "typeRoots_1", ".", "length", ";", "_i", "++", ")", "{", "var", "root", "=", "typeRoots_1", "[", "_i", "]", ";", "if", "(", "host", ".", "directoryExists", "(", "root", ")", ")", "{", "for", "(", "var", "_a", "=", "0", ",", "_b", "=", "host", ".", "getDirectories", "(", "root", ")", ";", "_a", "<", "_b", ".", "length", ";", "_a", "++", ")", "{", "var", "typeDirectivePath", "=", "_b", "[", "_a", "]", ";", "var", "normalized", "=", "ts", ".", "normalizePath", "(", "typeDirectivePath", ")", ";", "var", "packageJsonPath", "=", "ts", ".", "pathToPackageJson", "(", "ts", ".", "combinePaths", "(", "root", ",", "normalized", ")", ")", ";", "var", "isNotNeededPackage", "=", "host", ".", "fileExists", "(", "packageJsonPath", ")", "&&", "ts", ".", "readJson", "(", "packageJsonPath", ",", "host", ")", ".", "typings", "===", "null", ";", "if", "(", "!", "isNotNeededPackage", ")", "{", "result", ".", "push", "(", "ts", ".", "getBaseFileName", "(", "normalized", ")", ")", ";", "}", "}", "}", "}", "}", "}", "return", "result", ";", "}" ]

[ "Given", "a", "set", "of", "options", "returns", "the", "set", "of", "type", "directive", "names", "that", "should", "be", "included", "for", "this", "program", "automatically", ".", "This", "list", "could", "either", "come", "from", "the", "config", "file", "or", "from", "enumerating", "the", "types", "root", "+", "initial", "secondary", "types", "lookup", "location", ".", "More", "type", "directives", "might", "appear", "in", "the", "program", "later", "as", "a", "result", "of", "loading", "actual", "source", "files", ";", "this", "list", "is", "only", "the", "set", "of", "defaults", "that", "are", "implicitly", "included", "." ]

[ "function", "findSourceFile", "(", "fileName", ",", "path", ",", "isDefaultLib", ",", "isReference", ",", "refFile", ",", "refPos", ",", "refEnd", ")", "{", "if", "(", "filesByName", ".", "contains", "(", "path", ")", ")", "{", "var", "file_1", "=", "filesByName", ".", "get", "(", "path", ")", ";", "if", "(", "file_1", "&&", "options", ".", "forceConsistentCasingInFileNames", "&&", "ts", ".", "getNormalizedAbsolutePath", "(", "file_1", ".", "fileName", ",", "currentDirectory", ")", "!==", "ts", ".", "getNormalizedAbsolutePath", "(", "fileName", ",", "currentDirectory", ")", ")", "{", "reportFileNamesDifferOnlyInCasingError", "(", "fileName", ",", "file_1", ".", "fileName", ",", "refFile", ",", "refPos", ",", "refEnd", ")", ";", "}", "if", "(", "file_1", "&&", "sourceFilesFoundSearchingNodeModules", "[", "file_1", ".", "path", "]", "&&", "currentNodeModulesDepth", "==", "0", ")", "{", "sourceFilesFoundSearchingNodeModules", "[", "file_1", ".", "path", "]", "=", "false", ";", "if", "(", "!", "options", ".", "noResolve", ")", "{", "processReferencedFiles", "(", "file_1", ",", "ts", ".", "getDirectoryPath", "(", "fileName", ")", ",", "isDefaultLib", ")", ";", "processTypeReferenceDirectives", "(", "file_1", ")", ";", "}", "modulesWithElidedImports", "[", "file_1", ".", "path", "]", "=", "false", ";", "processImportedModules", "(", "file_1", ",", "ts", ".", "getDirectoryPath", "(", "fileName", ")", ")", ";", "}", "else", "if", "(", "file_1", "&&", "modulesWithElidedImports", "[", "file_1", ".", "path", "]", ")", "{", "if", "(", "currentNodeModulesDepth", "<", "maxNodeModulesJsDepth", ")", "{", "modulesWithElidedImports", "[", "file_1", ".", "path", "]", "=", "false", ";", "processImportedModules", "(", "file_1", ",", "ts", ".", "getDirectoryPath", "(", "fileName", ")", ")", ";", "}", "}", "return", "file_1", ";", "}", "var", "file", "=", "host", ".", "getSourceFile", "(", "fileName", ",", "options", ".", "target", ",", "function", "(", "hostErrorMessage", ")", "{", "if", "(", "refFile", "!==", "undefined", "&&", "refPos", "!==", "undefined", "&&", "refEnd", "!==", "undefined", ")", "{", "fileProcessingDiagnostics", ".", "add", "(", "ts", ".", "createFileDiagnostic", "(", "refFile", ",", "refPos", ",", "refEnd", "-", "refPos", ",", "ts", ".", "Diagnostics", ".", "Cannot_read_file_0_Colon_1", ",", "fileName", ",", "hostErrorMessage", ")", ")", ";", "}", "else", "{", "fileProcessingDiagnostics", ".", "add", "(", "ts", ".", "createCompilerDiagnostic", "(", "ts", ".", "Diagnostics", ".", "Cannot_read_file_0_Colon_1", ",", "fileName", ",", "hostErrorMessage", ")", ")", ";", "}", "}", ")", ";", "filesByName", ".", "set", "(", "path", ",", "file", ")", ";", "if", "(", "file", ")", "{", "sourceFilesFoundSearchingNodeModules", "[", "path", "]", "=", "(", "currentNodeModulesDepth", ">", "0", ")", ";", "file", ".", "path", "=", "path", ";", "if", "(", "host", ".", "useCaseSensitiveFileNames", "(", ")", ")", "{", "var", "existingFile", "=", "filesByNameIgnoreCase", ".", "get", "(", "path", ")", ";", "if", "(", "existingFile", ")", "{", "reportFileNamesDifferOnlyInCasingError", "(", "fileName", ",", "existingFile", ".", "fileName", ",", "refFile", ",", "refPos", ",", "refEnd", ")", ";", "}", "else", "{", "filesByNameIgnoreCase", ".", "set", "(", "path", ",", "file", ")", ";", "}", "}", "skipDefaultLib", "=", "skipDefaultLib", "||", "file", ".", "hasNoDefaultLib", ";", "var", "basePath", "=", "ts", ".", "getDirectoryPath", "(", "fileName", ")", ";", "if", "(", "!", "options", ".", "noResolve", ")", "{", "processReferencedFiles", "(", "file", ",", "basePath", ",", "isDefaultLib", ")", ";", "processTypeReferenceDirectives", "(", "file", ")", ";", "}", "processImportedModules", "(", "file", ",", "basePath", ")", ";", "if", "(", "isDefaultLib", ")", "{", "files", ".", "unshift", "(", "file", ")", ";", "}", "else", "{", "files", ".", "push", "(", "file", ")", ";", "}", "}", "return", "file", ";", "}" ]

[ "Get", "source", "file", "from", "normalized", "fileName" ]

[ "function", "verifyEmitFilePath", "(", "emitFileName", ",", "emitFilesSeen", ")", "{", "if", "(", "emitFileName", ")", "{", "var", "emitFilePath", "=", "ts", ".", "toPath", "(", "emitFileName", ",", "currentDirectory", ",", "getCanonicalFileName", ")", ";", "if", "(", "filesByName", ".", "contains", "(", "emitFilePath", ")", ")", "{", "createEmitBlockingDiagnostics", "(", "emitFileName", ",", "emitFilePath", ",", "ts", ".", "Diagnostics", ".", "Cannot_write_file_0_because_it_would_overwrite_input_file", ")", ";", "}", "if", "(", "emitFilesSeen", ".", "contains", "(", "emitFilePath", ")", ")", "{", "createEmitBlockingDiagnostics", "(", "emitFileName", ",", "emitFilePath", ",", "ts", ".", "Diagnostics", ".", "Cannot_write_file_0_because_it_would_be_overwritten_by_multiple_input_files", ")", ";", "}", "else", "{", "emitFilesSeen", ".", "set", "(", "emitFilePath", ",", "true", ")", ";", "}", "}", "}" ]

[ "Verify", "that", "all", "the", "emit", "files", "are", "unique", "and", "don", "t", "overwrite", "input", "files" ]

[ "function", "parseConfigFileTextToJson", "(", "fileName", ",", "jsonText", ",", "stripComments", ")", "{", "if", "(", "stripComments", "===", "void", "0", ")", "{", "stripComments", "=", "true", ";", "}", "try", "{", "var", "jsonTextToParse", "=", "stripComments", "?", "removeComments", "(", "jsonText", ")", ":", "jsonText", ";", "return", "{", "config", ":", "/", "\\S", "/", ".", "test", "(", "jsonTextToParse", ")", "?", "JSON", ".", "parse", "(", "jsonTextToParse", ")", ":", "{", "}", "}", ";", "}", "catch", "(", "e", ")", "{", "return", "{", "error", ":", "ts", ".", "createCompilerDiagnostic", "(", "ts", ".", "Diagnostics", ".", "Failed_to_parse_file_0_Colon_1", ",", "fileName", ",", "e", ".", "message", ")", "}", ";", "}", "}" ]

[ "Parse", "the", "text", "of", "the", "tsconfig", ".", "json", "file" ]

[ "function", "matchFileNames", "(", "fileNames", ",", "include", ",", "exclude", ",", "basePath", ",", "options", ",", "host", ",", "errors", ")", "{", "basePath", "=", "ts", ".", "normalizePath", "(", "basePath", ")", ";", "var", "keyMapper", "=", "host", ".", "useCaseSensitiveFileNames", "?", "caseSensitiveKeyMapper", ":", "caseInsensitiveKeyMapper", ";", "var", "literalFileMap", "=", "ts", ".", "createMap", "(", ")", ";", "var", "wildcardFileMap", "=", "ts", ".", "createMap", "(", ")", ";", "if", "(", "include", ")", "{", "include", "=", "validateSpecs", "(", "include", ",", "errors", ",", "false", ")", ";", "}", "if", "(", "exclude", ")", "{", "exclude", "=", "validateSpecs", "(", "exclude", ",", "errors", ",", "true", ")", ";", "}", "var", "wildcardDirectories", "=", "getWildcardDirectories", "(", "include", ",", "exclude", ",", "basePath", ",", "host", ".", "useCaseSensitiveFileNames", ")", ";", "var", "supportedExtensions", "=", "ts", ".", "getSupportedExtensions", "(", "options", ")", ";", "if", "(", "fileNames", ")", "{", "for", "(", "var", "_i", "=", "0", ",", "fileNames_1", "=", "fileNames", ";", "_i", "<", "fileNames_1", ".", "length", ";", "_i", "++", ")", "{", "var", "fileName", "=", "fileNames_1", "[", "_i", "]", ";", "var", "file", "=", "ts", ".", "combinePaths", "(", "basePath", ",", "fileName", ")", ";", "literalFileMap", "[", "keyMapper", "(", "file", ")", "]", "=", "file", ";", "}", "}", "if", "(", "include", "&&", "include", ".", "length", ">", "0", ")", "{", "for", "(", "var", "_a", "=", "0", ",", "_b", "=", "host", ".", "readDirectory", "(", "basePath", ",", "supportedExtensions", ",", "exclude", ",", "include", ")", ";", "_a", "<", "_b", ".", "length", ";", "_a", "++", ")", "{", "var", "file", "=", "_b", "[", "_a", "]", ";", "if", "(", "hasFileWithHigherPriorityExtension", "(", "file", ",", "literalFileMap", ",", "wildcardFileMap", ",", "supportedExtensions", ",", "keyMapper", ")", ")", "{", "continue", ";", "}", "removeWildcardFilesWithLowerPriorityExtension", "(", "file", ",", "wildcardFileMap", ",", "supportedExtensions", ",", "keyMapper", ")", ";", "var", "key", "=", "keyMapper", "(", "file", ")", ";", "if", "(", "!", "(", "key", "in", "literalFileMap", ")", "&&", "!", "(", "key", "in", "wildcardFileMap", ")", ")", "{", "wildcardFileMap", "[", "key", "]", "=", "file", ";", "}", "}", "}", "var", "literalFiles", "=", "ts", ".", "reduceProperties", "(", "literalFileMap", ",", "addFileToOutput", ",", "[", "]", ")", ";", "var", "wildcardFiles", "=", "ts", ".", "reduceProperties", "(", "wildcardFileMap", ",", "addFileToOutput", ",", "[", "]", ")", ";", "wildcardFiles", ".", "sort", "(", "host", ".", "useCaseSensitiveFileNames", "?", "ts", ".", "compareStrings", ":", "ts", ".", "compareStringsCaseInsensitive", ")", ";", "return", "{", "fileNames", ":", "literalFiles", ".", "concat", "(", "wildcardFiles", ")", ",", "wildcardDirectories", ":", "wildcardDirectories", "}", ";", "}" ]

[ "Expands", "an", "array", "of", "file", "specifications", "." ]

[ "function", "getWildcardDirectories", "(", "include", ",", "exclude", ",", "path", ",", "useCaseSensitiveFileNames", ")", "{", "var", "rawExcludeRegex", "=", "ts", ".", "getRegularExpressionForWildcard", "(", "exclude", ",", "path", ",", "\"exclude\"", ")", ";", "var", "excludeRegex", "=", "rawExcludeRegex", "&&", "new", "RegExp", "(", "rawExcludeRegex", ",", "useCaseSensitiveFileNames", "?", "\"\"", ":", "\"i\"", ")", ";", "var", "wildcardDirectories", "=", "ts", ".", "createMap", "(", ")", ";", "if", "(", "include", "!==", "undefined", ")", "{", "var", "recursiveKeys", "=", "[", "]", ";", "for", "(", "var", "_i", "=", "0", ",", "include_1", "=", "include", ";", "_i", "<", "include_1", ".", "length", ";", "_i", "++", ")", "{", "var", "file", "=", "include_1", "[", "_i", "]", ";", "var", "name_36", "=", "ts", ".", "normalizePath", "(", "ts", ".", "combinePaths", "(", "path", ",", "file", ")", ")", ";", "if", "(", "excludeRegex", "&&", "excludeRegex", ".", "test", "(", "name_36", ")", ")", "{", "continue", ";", "}", "var", "match", "=", "wildcardDirectoryPattern", ".", "exec", "(", "name_36", ")", ";", "if", "(", "match", ")", "{", "var", "key", "=", "useCaseSensitiveFileNames", "?", "match", "[", "0", "]", ":", "match", "[", "0", "]", ".", "toLowerCase", "(", ")", ";", "var", "flags", "=", "watchRecursivePattern", ".", "test", "(", "name_36", ")", "?", "1", ":", "0", ";", "var", "existingFlags", "=", "wildcardDirectories", "[", "key", "]", ";", "if", "(", "existingFlags", "===", "undefined", "||", "existingFlags", "<", "flags", ")", "{", "wildcardDirectories", "[", "key", "]", "=", "flags", ";", "if", "(", "flags", "===", "1", ")", "{", "recursiveKeys", ".", "push", "(", "key", ")", ";", "}", "}", "}", "}", "for", "(", "var", "key", "in", "wildcardDirectories", ")", "{", "for", "(", "var", "_a", "=", "0", ",", "recursiveKeys_1", "=", "recursiveKeys", ";", "_a", "<", "recursiveKeys_1", ".", "length", ";", "_a", "++", ")", "{", "var", "recursiveKey", "=", "recursiveKeys_1", "[", "_a", "]", ";", "if", "(", "key", "!==", "recursiveKey", "&&", "ts", ".", "containsPath", "(", "recursiveKey", ",", "key", ",", "path", ",", "!", "useCaseSensitiveFileNames", ")", ")", "{", "delete", "wildcardDirectories", "[", "key", "]", ";", "}", "}", "}", "}", "return", "wildcardDirectories", ";", "}" ]

[ "Gets", "directories", "in", "a", "set", "of", "include", "patterns", "that", "should", "be", "watched", "for", "changes", "." ]

[ "function", "hasFileWithHigherPriorityExtension", "(", "file", ",", "literalFiles", ",", "wildcardFiles", ",", "extensions", ",", "keyMapper", ")", "{", "var", "extensionPriority", "=", "ts", ".", "getExtensionPriority", "(", "file", ",", "extensions", ")", ";", "var", "adjustedExtensionPriority", "=", "ts", ".", "adjustExtensionPriority", "(", "extensionPriority", ")", ";", "for", "(", "var", "i", "=", "0", ";", "i", "<", "adjustedExtensionPriority", ";", "i", "++", ")", "{", "var", "higherPriorityExtension", "=", "extensions", "[", "i", "]", ";", "var", "higherPriorityPath", "=", "keyMapper", "(", "ts", ".", "changeExtension", "(", "file", ",", "higherPriorityExtension", ")", ")", ";", "if", "(", "higherPriorityPath", "in", "literalFiles", "||", "higherPriorityPath", "in", "wildcardFiles", ")", "{", "return", "true", ";", "}", "}", "return", "false", ";", "}" ]

[ "Determines", "whether", "a", "literal", "or", "wildcard", "file", "has", "already", "been", "included", "that", "has", "a", "higher", "extension", "priority", "." ]

[ "function", "removeWildcardFilesWithLowerPriorityExtension", "(", "file", ",", "wildcardFiles", ",", "extensions", ",", "keyMapper", ")", "{", "var", "extensionPriority", "=", "ts", ".", "getExtensionPriority", "(", "file", ",", "extensions", ")", ";", "var", "nextExtensionPriority", "=", "ts", ".", "getNextLowestExtensionPriority", "(", "extensionPriority", ")", ";", "for", "(", "var", "i", "=", "nextExtensionPriority", ";", "i", "<", "extensions", ".", "length", ";", "i", "++", ")", "{", "var", "lowerPriorityExtension", "=", "extensions", "[", "i", "]", ";", "var", "lowerPriorityPath", "=", "keyMapper", "(", "ts", ".", "changeExtension", "(", "file", ",", "lowerPriorityExtension", ")", ")", ";", "delete", "wildcardFiles", "[", "lowerPriorityPath", "]", ";", "}", "}" ]

[ "Removes", "files", "included", "via", "wildcard", "expansion", "with", "a", "lower", "extension", "priority", "that", "have", "already", "been", "included", "." ]

[ "function", "startNode", "(", "node", ")", "{", "var", "navNode", "=", "emptyNavigationBarNode", "(", "node", ")", ";", "pushChild", "(", "parent", ",", "navNode", ")", ";", "parentsStack", ".", "push", "(", "parent", ")", ";", "parent", "=", "navNode", ";", "}" ]

[ "Add", "a", "new", "level", "of", "NavigationBarNodes", ".", "This", "pushes", "to", "the", "stack", "so", "you", "must", "call", "endNode", "when", "you", "are", "done", "adding", "to", "this", "node", "." ]

[ "function", "endNode", "(", ")", "{", "if", "(", "parent", ".", "children", ")", "{", "mergeChildren", "(", "parent", ".", "children", ")", ";", "sortChildren", "(", "parent", ".", "children", ")", ";", "}", "parent", "=", "parentsStack", ".", "pop", "(", ")", ";", "}" ]

[ "Call", "after", "calling", "startNode", "and", "adding", "children", "to", "it", "." ]

[ "function", "mergeChildren", "(", "children", ")", "{", "var", "nameToItems", "=", "ts", ".", "createMap", "(", ")", ";", "ts", ".", "filterMutate", "(", "children", ",", "function", "(", "child", ")", "{", "var", "decl", "=", "child", ".", "node", ";", "var", "name", "=", "decl", ".", "name", "&&", "nodeText", "(", "decl", ".", "name", ")", ";", "if", "(", "!", "name", ")", "{", "return", "true", ";", "}", "var", "itemsWithSameName", "=", "nameToItems", "[", "name", "]", ";", "if", "(", "!", "itemsWithSameName", ")", "{", "nameToItems", "[", "name", "]", "=", "child", ";", "return", "true", ";", "}", "if", "(", "itemsWithSameName", "instanceof", "Array", ")", "{", "for", "(", "var", "_i", "=", "0", ",", "itemsWithSameName_1", "=", "itemsWithSameName", ";", "_i", "<", "itemsWithSameName_1", ".", "length", ";", "_i", "++", ")", "{", "var", "itemWithSameName", "=", "itemsWithSameName_1", "[", "_i", "]", ";", "if", "(", "tryMerge", "(", "itemWithSameName", ",", "child", ")", ")", "{", "return", "false", ";", "}", "}", "itemsWithSameName", ".", "push", "(", "child", ")", ";", "return", "true", ";", "}", "else", "{", "var", "itemWithSameName", "=", "itemsWithSameName", ";", "if", "(", "tryMerge", "(", "itemWithSameName", ",", "child", ")", ")", "{", "return", "false", ";", "}", "nameToItems", "[", "name", "]", "=", "[", "itemWithSameName", ",", "child", "]", ";", "return", "true", ";", "}", "function", "tryMerge", "(", "a", ",", "b", ")", "{", "if", "(", "shouldReallyMerge", "(", "a", ".", "node", ",", "b", ".", "node", ")", ")", "{", "merge", "(", "a", ",", "b", ")", ";", "return", "true", ";", "}", "return", "false", ";", "}", "}", ")", ";", "function", "shouldReallyMerge", "(", "a", ",", "b", ")", "{", "return", "a", ".", "kind", "===", "b", ".", "kind", "&&", "(", "a", ".", "kind", "!==", "225", "||", "areSameModule", "(", "a", ",", "b", ")", ")", ";", "function", "areSameModule", "(", "a", ",", "b", ")", "{", "if", "(", "a", ".", "body", ".", "kind", "!==", "b", ".", "body", ".", "kind", ")", "{", "return", "false", ";", "}", "if", "(", "a", ".", "body", ".", "kind", "!==", "225", ")", "{", "return", "true", ";", "}", "return", "areSameModule", "(", "a", ".", "body", ",", "b", ".", "body", ")", ";", "}", "}", "function", "merge", "(", "target", ",", "source", ")", "{", "target", ".", "additionalNodes", "=", "target", ".", "additionalNodes", "||", "[", "]", ";", "target", ".", "additionalNodes", ".", "push", "(", "source", ".", "node", ")", ";", "if", "(", "source", ".", "additionalNodes", ")", "{", "(", "_a", "=", "target", ".", "additionalNodes", ")", ".", "push", ".", "apply", "(", "_a", ",", "source", ".", "additionalNodes", ")", ";", "}", "target", ".", "children", "=", "ts", ".", "concatenate", "(", "target", ".", "children", ",", "source", ".", "children", ")", ";", "if", "(", "target", ".", "children", ")", "{", "mergeChildren", "(", "target", ".", "children", ")", ";", "sortChildren", "(", "target", ".", "children", ")", ";", "}", "var", "_a", ";", "}", "}" ]

[ "Merge", "declarations", "of", "the", "same", "kind", "." ]

[ "function", "shouldReallyMerge", "(", "a", ",", "b", ")", "{", "return", "a", ".", "kind", "===", "b", ".", "kind", "&&", "(", "a", ".", "kind", "!==", "225", "||", "areSameModule", "(", "a", ",", "b", ")", ")", ";", "function", "areSameModule", "(", "a", ",", "b", ")", "{", "if", "(", "a", ".", "body", ".", "kind", "!==", "b", ".", "body", ".", "kind", ")", "{", "return", "false", ";", "}", "if", "(", "a", ".", "body", ".", "kind", "!==", "225", ")", "{", "return", "true", ";", "}", "return", "areSameModule", "(", "a", ".", "body", ",", "b", ".", "body", ")", ";", "}", "}" ]

[ "a", "and", "b", "have", "the", "same", "name", "but", "they", "may", "not", "be", "mergeable", "." ]

[ "function", "areSameModule", "(", "a", ",", "b", ")", "{", "if", "(", "a", ".", "body", ".", "kind", "!==", "b", ".", "body", ".", "kind", ")", "{", "return", "false", ";", "}", "if", "(", "a", ".", "body", ".", "kind", "!==", "225", ")", "{", "return", "true", ";", "}", "return", "areSameModule", "(", "a", ".", "body", ",", "b", ".", "body", ")", ";", "}" ]

[ "We", "use", "1", "NavNode", "to", "represent", "A", ".", "B", ".", "C", "but", "there", "are", "multiple", "source", "nodes", ".", "Only", "merge", "module", "nodes", "that", "have", "the", "same", "chain", ".", "Don", "t", "merge", "A", ".", "B", ".", "C", "with", "A", "!" ]

[ "function", "merge", "(", "target", ",", "source", ")", "{", "target", ".", "additionalNodes", "=", "target", ".", "additionalNodes", "||", "[", "]", ";", "target", ".", "additionalNodes", ".", "push", "(", "source", ".", "node", ")", ";", "if", "(", "source", ".", "additionalNodes", ")", "{", "(", "_a", "=", "target", ".", "additionalNodes", ")", ".", "push", ".", "apply", "(", "_a", ",", "source", ".", "additionalNodes", ")", ";", "}", "target", ".", "children", "=", "ts", ".", "concatenate", "(", "target", ".", "children", ",", "source", ".", "children", ")", ";", "if", "(", "target", ".", "children", ")", "{", "mergeChildren", "(", "target", ".", "children", ")", ";", "sortChildren", "(", "target", ".", "children", ")", ";", "}", "var", "_a", ";", "}" ]

[ "Merge", "source", "into", "target", ".", "Source", "should", "be", "thrown", "away", "after", "this", "is", "called", "." ]

[ "function", "topLevelItems", "(", "root", ")", "{", "var", "topLevel", "=", "[", "]", ";", "function", "recur", "(", "item", ")", "{", "if", "(", "isTopLevel", "(", "item", ")", ")", "{", "topLevel", ".", "push", "(", "item", ")", ";", "if", "(", "item", ".", "children", ")", "{", "for", "(", "var", "_i", "=", "0", ",", "_a", "=", "item", ".", "children", ";", "_i", "<", "_a", ".", "length", ";", "_i", "++", ")", "{", "var", "child", "=", "_a", "[", "_i", "]", ";", "recur", "(", "child", ")", ";", "}", "}", "}", "}", "recur", "(", "root", ")", ";", "return", "topLevel", ";", "function", "isTopLevel", "(", "item", ")", "{", "switch", "(", "navigationBarNodeKind", "(", "item", ")", ")", "{", "case", "221", ":", "case", "192", ":", "case", "224", ":", "case", "222", ":", "case", "225", ":", "case", "256", ":", "case", "223", ":", "case", "279", ":", "return", "true", ";", "case", "148", ":", "case", "147", ":", "case", "149", ":", "case", "150", ":", "return", "hasSomeImportantChild", "(", "item", ")", ";", "case", "180", ":", "case", "220", ":", "case", "179", ":", "return", "isTopLevelFunctionDeclaration", "(", "item", ")", ";", "default", ":", "return", "false", ";", "}", "function", "isTopLevelFunctionDeclaration", "(", "item", ")", "{", "if", "(", "!", "item", ".", "node", ".", "body", ")", "{", "return", "false", ";", "}", "switch", "(", "navigationBarNodeKind", "(", "item", ".", "parent", ")", ")", "{", "case", "226", ":", "case", "256", ":", "case", "147", ":", "case", "148", ":", "return", "true", ";", "default", ":", "return", "hasSomeImportantChild", "(", "item", ")", ";", "}", "}", "function", "hasSomeImportantChild", "(", "item", ")", "{", "return", "ts", ".", "forEach", "(", "item", ".", "children", ",", "function", "(", "child", ")", "{", "var", "childKind", "=", "navigationBarNodeKind", "(", "child", ")", ";", "return", "childKind", "!==", "218", "&&", "childKind", "!==", "169", ";", "}", ")", ";", "}", "}", "}" ]

[ "Flattens", "the", "NavNode", "tree", "to", "a", "list", "keeping", "only", "the", "top", "-", "level", "items", "." ]

[ "function", "getArgumentIndexForTemplatePiece", "(", "spanIndex", ",", "node", ",", "position", ")", "{", "ts", ".", "Debug", ".", "assert", "(", "position", ">=", "node", ".", "getStart", "(", ")", ",", "\"Assumed 'position' could not occur before node.\"", ")", ";", "if", "(", "ts", ".", "isTemplateLiteralKind", "(", "node", ".", "kind", ")", ")", "{", "if", "(", "ts", ".", "isInsideTemplateLiteral", "(", "node", ",", "position", ")", ")", "{", "return", "0", ";", "}", "return", "spanIndex", "+", "2", ";", "}", "return", "spanIndex", "+", "1", ";", "}" ]

[ "spanIndex", "is", "either", "the", "index", "for", "a", "given", "template", "span", ".", "This", "does", "not", "give", "appropriate", "results", "for", "a", "NoSubstitutionTemplateLiteral" ]

[ "function", "getTokenAtPosition", "(", "sourceFile", ",", "position", ",", "includeJsDocComment", ")", "{", "if", "(", "includeJsDocComment", "===", "void", "0", ")", "{", "includeJsDocComment", "=", "false", ";", "}", "return", "getTokenAtPositionWorker", "(", "sourceFile", ",", "position", ",", "true", ",", "undefined", ",", "includeJsDocComment", ")", ";", "}" ]

[ "Returns", "a", "token", "if", "position", "is", "in", "[", "start", "-", "of", "-", "leading", "-", "trivia", "end", ")" ]

[ "function", "isInsideJsxElementOrAttribute", "(", "sourceFile", ",", "position", ")", "{", "var", "token", "=", "getTokenAtPosition", "(", "sourceFile", ",", "position", ")", ";", "if", "(", "!", "token", ")", "{", "return", "false", ";", "}", "if", "(", "token", ".", "kind", "===", "244", ")", "{", "return", "true", ";", "}", "if", "(", "token", ".", "kind", "===", "25", "&&", "token", ".", "parent", ".", "kind", "===", "244", ")", "{", "return", "true", ";", "}", "if", "(", "token", ".", "kind", "===", "25", "&&", "token", ".", "parent", ".", "kind", "===", "248", ")", "{", "return", "true", ";", "}", "if", "(", "token", "&&", "token", ".", "kind", "===", "16", "&&", "token", ".", "parent", ".", "kind", "===", "248", ")", "{", "return", "true", ";", "}", "if", "(", "token", ".", "kind", "===", "25", "&&", "token", ".", "parent", ".", "kind", "===", "245", ")", "{", "return", "true", ";", "}", "return", "false", ";", "}" ]

[ "returns", "true", "if", "the", "position", "is", "in", "between", "the", "open", "and", "close", "elements", "of", "an", "JSX", "expression", "." ]

[ "function", "isInCommentHelper", "(", "sourceFile", ",", "position", ",", "predicate", ")", "{", "var", "token", "=", "getTokenAtPosition", "(", "sourceFile", ",", "position", ")", ";", "if", "(", "token", "&&", "position", "<=", "token", ".", "getStart", "(", "sourceFile", ")", ")", "{", "var", "commentRanges", "=", "ts", ".", "getLeadingCommentRanges", "(", "sourceFile", ".", "text", ",", "token", ".", "pos", ")", ";", "return", "predicate", "?", "ts", ".", "forEach", "(", "commentRanges", ",", "function", "(", "c", ")", "{", "return", "c", ".", "pos", "<", "position", "&&", "(", "c", ".", "kind", "==", "2", "?", "position", "<=", "c", ".", "end", ":", "position", "<", "c", ".", "end", ")", "&&", "predicate", "(", "c", ")", ";", "}", ")", ":", "ts", ".", "forEach", "(", "commentRanges", ",", "function", "(", "c", ")", "{", "return", "c", ".", "pos", "<", "position", "&&", "(", "c", ".", "kind", "==", "2", "?", "position", "<=", "c", ".", "end", ":", "position", "<", "c", ".", "end", ")", ";", "}", ")", ";", "}", "return", "false", ";", "}" ]

[ "Returns", "true", "if", "the", "cursor", "at", "position", "in", "sourceFile", "is", "within", "a", "comment", "that", "additionally", "satisfies", "predicate", "and", "false", "otherwise", "." ]

[ "function", "mergeTypings", "(", "typingNames", ")", "{", "if", "(", "!", "typingNames", ")", "{", "return", ";", "}", "for", "(", "var", "_i", "=", "0", ",", "typingNames_1", "=", "typingNames", ";", "_i", "<", "typingNames_1", ".", "length", ";", "_i", "++", ")", "{", "var", "typing", "=", "typingNames_1", "[", "_i", "]", ";", "if", "(", "!", "(", "typing", "in", "inferredTypings", ")", ")", "{", "inferredTypings", "[", "typing", "]", "=", "undefined", ";", "}", "}", "}" ]

[ "Merge", "a", "given", "list", "of", "typingNames", "to", "the", "inferredTypings", "map" ]

[ "function", "getTypingNamesFromJson", "(", "jsonPath", ",", "filesToWatch", ")", "{", "if", "(", "host", ".", "fileExists", "(", "jsonPath", ")", ")", "{", "filesToWatch", ".", "push", "(", "jsonPath", ")", ";", "}", "var", "result", "=", "ts", ".", "readConfigFile", "(", "jsonPath", ",", "function", "(", "path", ")", "{", "return", "host", ".", "readFile", "(", "path", ")", ";", "}", ")", ";", "if", "(", "result", ".", "config", ")", "{", "var", "jsonConfig", "=", "result", ".", "config", ";", "if", "(", "jsonConfig", ".", "dependencies", ")", "{", "mergeTypings", "(", "ts", ".", "getOwnKeys", "(", "jsonConfig", ".", "dependencies", ")", ")", ";", "}", "if", "(", "jsonConfig", ".", "devDependencies", ")", "{", "mergeTypings", "(", "ts", ".", "getOwnKeys", "(", "jsonConfig", ".", "devDependencies", ")", ")", ";", "}", "if", "(", "jsonConfig", ".", "optionalDependencies", ")", "{", "mergeTypings", "(", "ts", ".", "getOwnKeys", "(", "jsonConfig", ".", "optionalDependencies", ")", ")", ";", "}", "if", "(", "jsonConfig", ".", "peerDependencies", ")", "{", "mergeTypings", "(", "ts", ".", "getOwnKeys", "(", "jsonConfig", ".", "peerDependencies", ")", ")", ";", "}", "}", "}" ]

[ "Get", "the", "typing", "info", "from", "common", "package", "manager", "json", "files", "like", "package", ".", "json", "or", "bower", ".", "json" ]

[ "function", "getTypingNamesFromSourceFileNames", "(", "fileNames", ")", "{", "var", "jsFileNames", "=", "ts", ".", "filter", "(", "fileNames", ",", "ts", ".", "hasJavaScriptFileExtension", ")", ";", "var", "inferredTypingNames", "=", "ts", ".", "map", "(", "jsFileNames", ",", "function", "(", "f", ")", "{", "return", "ts", ".", "removeFileExtension", "(", "ts", ".", "getBaseFileName", "(", "f", ".", "toLowerCase", "(", ")", ")", ")", ";", "}", ")", ";", "var", "cleanedTypingNames", "=", "ts", ".", "map", "(", "inferredTypingNames", ",", "function", "(", "f", ")", "{", "return", "f", ".", "replace", "(", "/", "((?:\\.|-)min(?=\\.|$))|((?:-|\\.)\\d+)", "/", "g", ",", "\"\"", ")", ";", "}", ")", ";", "if", "(", "safeList", "!==", "EmptySafeList", ")", "{", "mergeTypings", "(", "ts", ".", "filter", "(", "cleanedTypingNames", ",", "function", "(", "f", ")", "{", "return", "f", "in", "safeList", ";", "}", ")", ")", ";", "}", "var", "hasJsxFile", "=", "ts", ".", "forEach", "(", "fileNames", ",", "function", "(", "f", ")", "{", "return", "ts", ".", "ensureScriptKind", "(", "f", ",", "ts", ".", "getScriptKindFromFileName", "(", "f", ")", ")", "===", "2", ";", "}", ")", ";", "if", "(", "hasJsxFile", ")", "{", "mergeTypings", "(", "[", "\"react\"", "]", ")", ";", "}", "}" ]

[ "Infer", "typing", "names", "from", "given", "file", "names", ".", "For", "example", "the", "file", "name", "jquery", "-", "min", ".", "2", ".", "3", ".", "4", ".", "js", "should", "be", "inferred", "to", "the", "jquery", "typing", "name", ";", "and", "angular", "-", "route", ".", "1", ".", "2", ".", "3", ".", "js", "should", "be", "inferred", "to", "the", "angular", "-", "route", "typing", "name", "." ]

[ "function", "getTypingNamesFromNodeModuleFolder", "(", "nodeModulesPath", ")", "{", "if", "(", "!", "host", ".", "directoryExists", "(", "nodeModulesPath", ")", ")", "{", "return", ";", "}", "var", "typingNames", "=", "[", "]", ";", "var", "fileNames", "=", "host", ".", "readDirectory", "(", "nodeModulesPath", ",", "[", "\".json\"", "]", ",", "undefined", ",", "undefined", ",", "2", ")", ";", "for", "(", "var", "_i", "=", "0", ",", "fileNames_2", "=", "fileNames", ";", "_i", "<", "fileNames_2", ".", "length", ";", "_i", "++", ")", "{", "var", "fileName", "=", "fileNames_2", "[", "_i", "]", ";", "var", "normalizedFileName", "=", "ts", ".", "normalizePath", "(", "fileName", ")", ";", "if", "(", "ts", ".", "getBaseFileName", "(", "normalizedFileName", ")", "!==", "\"package.json\"", ")", "{", "continue", ";", "}", "var", "result", "=", "ts", ".", "readConfigFile", "(", "normalizedFileName", ",", "function", "(", "path", ")", "{", "return", "host", ".", "readFile", "(", "path", ")", ";", "}", ")", ";", "if", "(", "!", "result", ".", "config", ")", "{", "continue", ";", "}", "var", "packageJson", "=", "result", ".", "config", ";", "if", "(", "packageJson", ".", "_requiredBy", "&&", "ts", ".", "filter", "(", "packageJson", ".", "_requiredBy", ",", "function", "(", "r", ")", "{", "return", "r", "[", "0", "]", "===", "\"#\"", "||", "r", "===", "\"/\"", ";", "}", ")", ".", "length", "===", "0", ")", "{", "continue", ";", "}", "if", "(", "!", "packageJson", ".", "name", ")", "{", "continue", ";", "}", "if", "(", "packageJson", ".", "typings", ")", "{", "var", "absolutePath", "=", "ts", ".", "getNormalizedAbsolutePath", "(", "packageJson", ".", "typings", ",", "ts", ".", "getDirectoryPath", "(", "normalizedFileName", ")", ")", ";", "inferredTypings", "[", "packageJson", ".", "name", "]", "=", "absolutePath", ";", "}", "else", "{", "typingNames", ".", "push", "(", "packageJson", ".", "name", ")", ";", "}", "}", "mergeTypings", "(", "typingNames", ")", ";", "}" ]

[ "Infer", "typing", "names", "from", "node_module", "folder" ]

[ "function", "getScanStartPosition", "(", "enclosingNode", ",", "originalRange", ",", "sourceFile", ")", "{", "var", "start", "=", "enclosingNode", ".", "getStart", "(", "sourceFile", ")", ";", "if", "(", "start", "===", "originalRange", ".", "pos", "&&", "enclosingNode", ".", "end", "===", "originalRange", ".", "end", ")", "{", "return", "start", ";", "}", "var", "precedingToken", "=", "ts", ".", "findPrecedingToken", "(", "originalRange", ".", "pos", ",", "sourceFile", ")", ";", "if", "(", "!", "precedingToken", ")", "{", "return", "enclosingNode", ".", "pos", ";", "}", "if", "(", "precedingToken", ".", "end", ">=", "originalRange", ".", "pos", ")", "{", "return", "enclosingNode", ".", "pos", ";", "}", "return", "precedingToken", ".", "end", ";", "}" ]

[ "Start", "of", "the", "original", "range", "might", "fall", "inside", "the", "comment", "-", "scanner", "will", "not", "yield", "appropriate", "results", "This", "function", "will", "look", "for", "token", "that", "is", "located", "before", "the", "start", "of", "target", "range", "and", "return", "its", "end", "as", "start", "position", "for", "the", "scanner", "." ]

[ "function", "tryComputeIndentationForListItem", "(", "startPos", ",", "endPos", ",", "parentStartLine", ",", "range", ",", "inheritedIndentation", ")", "{", "if", "(", "ts", ".", "rangeOverlapsWithStartEnd", "(", "range", ",", "startPos", ",", "endPos", ")", "||", "ts", ".", "rangeContainsStartEnd", "(", "range", ",", "startPos", ",", "endPos", ")", ")", "{", "if", "(", "inheritedIndentation", "!==", "-", "1", ")", "{", "return", "inheritedIndentation", ";", "}", "}", "else", "{", "var", "startLine", "=", "sourceFile", ".", "getLineAndCharacterOfPosition", "(", "startPos", ")", ".", "line", ";", "var", "startLinePosition", "=", "ts", ".", "getLineStartPositionForPosition", "(", "startPos", ",", "sourceFile", ")", ";", "var", "column", "=", "formatting", ".", "SmartIndenter", ".", "findFirstNonWhitespaceColumn", "(", "startLinePosition", ",", "startPos", ",", "sourceFile", ",", "options", ")", ";", "if", "(", "startLine", "!==", "parentStartLine", "||", "startPos", "===", "column", ")", "{", "var", "baseIndentSize", "=", "formatting", ".", "SmartIndenter", ".", "getBaseIndentation", "(", "options", ")", ";", "return", "baseIndentSize", ">", "column", "?", "baseIndentSize", ":", "column", ";", "}", "}", "return", "-", "1", ";", "}" ]

[ "local", "functions", "Tries", "to", "compute", "the", "indentation", "for", "a", "list", "element", ".", "If", "list", "element", "is", "not", "in", "range", "then", "function", "will", "pick", "its", "actual", "indentation", "so", "it", "can", "be", "pushed", "downstream", "as", "inherited", "indentation", ".", "If", "list", "element", "is", "in", "the", "range", "-", "its", "indentation", "will", "be", "equal", "to", "inherited", "indentation", "from", "its", "predecessors", "." ]