options = opts;

languageVersion = getEmitScriptTarget(options);

inStrictMode = bindInStrictMode(file, opts);

symbolCount = 0;

skipTransformFlagAggregation = isDeclarationFile(file);

symbol.declarations.push(node);

if (symbolFlags & SymbolFlags.HasExports && !symbol.exports) {

}

if (symbolFlags & SymbolFlags.HasMembers && !symbol.members) {

}

if (symbolFlags & SymbolFlags.Value) {

if (containerFlags & ContainerFlags.IsContainer) {

container = blockScopeContainer = node;

if (containerFlags & ContainerFlags.HasLocals) {

}

addToContainerChain(container);

}

const typeLiteralSymbol = createSymbol(SymbolFlags.TypeLiteral, "__type");

addDeclarationToSymbol(typeLiteralSymbol, node, SymbolFlags.TypeLiteral);

}

function bindObjectLiteralExpression(node: ObjectLiteralExpression) {

}

if (inStrictMode) {

for (const prop of node.properties) {

if (prop.name.kind !== SyntaxKind.Identifier) {

// fall through.

default:

if (!blockScopeContainer.locals) {

addToContainerChain(blockScopeContainer);

}

declareSymbol(blockScopeContainer.locals, undefined, node, symbolFlags, symbolExcludes);

}

}

declareSymbol(file.symbol.globalExports, file.symbol, node, SymbolFlags.Alias, SymbolFlags.AliasExcludes);

}

Debug.assert(isInJavaScriptFile(node));

// Declare a 'member' if the container is an ES5 class or ES6 constructor

if (container.kind === SyntaxKind.FunctionDeclaration || container.kind === SyntaxKind.FunctionExpression) {

// It's acceptable for multiple 'this' assignments of the same identifier to occur

declareSymbol(container.symbol.members, container.symbol, node, SymbolFlags.Property, SymbolFlags.PropertyExcludes & ~SymbolFlags.Property);

}

// Set up the members collection if it doesn't exist already

if (!funcSymbol.members) {

}

// Declare the method/property

let symbolCount = 0;

const emptyArray: any[] = [];

const compilerOptions = host.getCompilerOptions();

const languageVersion = compilerOptions.target || ScriptTarget.ES3;

};

const tupleTypes: GenericType[] = [];

const evolvingArrayTypes: EvolvingArrayType[] = [];

const unknownSymbol = createSymbol(SymbolFlags.Property | SymbolFlags.Transient, "unknown");

const emptyObjectType = createAnonymousType(undefined, emptySymbols, emptyArray, emptyArray, undefined, undefined);

const emptyGenericType = <GenericType><ObjectType>createAnonymousType(undefined, emptySymbols, emptyArray, emptyArray, undefined, undefined);

const anyFunctionType = createAnonymousType(undefined, emptySymbols, emptyArray, emptyArray, undefined, undefined);

// The anyFunctionType contains the anyFunctionType by definition. The flag is further propagated

const enumNumberIndexInfo = createIndexInfo(stringType, /*isReadonly*/ true);

/**

* List of every ambient module with a "*" wildcard.

* Unlike other ambient modules, these can't be stored in `globals` because symbol tables only deal with exact matches.

let jsxElementType: Type;

/** Things we lazy load from the JSX namespace */

const JsxNames = {

JSX: "JSX",

IntrinsicElements: "IntrinsicElements",

IntrinsicClassAttributes: "IntrinsicClassAttributes"

};

// This is for caching the result of getSymbolDisplayBuilder. Do not access directly.

let _displayBuilder: SymbolDisplayBuilder;

ResolvedReturnType

}

initializeTypeChecker();

target.declarations.push(node);

});

if (source.members) {

mergeSymbolTable(target.members, source.members);

}

if (source.exports) {

mergeSymbolTable(target.exports, source.exports);

}

recordMergedSymbol(target, source);

// This provides a name to the module. See the test tests/cases/fourslash/untypedModuleImport.ts

const newSymbol = createSymbol(SymbolFlags.ValueModule, quotedName);

// Module symbols are expected to have 'exports', although since this is an untyped module it can be empty.

// Cache it so subsequent accesses will return the same module.

globals.set(quotedName, newSymbol);

return newSymbol;

// All export * declarations are collected in an __export symbol by the binder

const exportStars = symbol.exports.get("__export");

if (exportStars) {

for (const node of exportStars.declarations) {

const resolvedModule = resolveExternalModuleName(node, (node as ExportDeclaration).moduleSpecifier);

const exportedSymbols = visit(resolvedModule);

// Return the type implied by an object binding pattern

function getTypeFromObjectBindingPattern(pattern: ObjectBindingPattern, includePatternInType: boolean, reportErrors: boolean): Type {

let hasComputedProperties = false;

forEach(pattern.elements, e => {

const name = e.propertyName || <Identifier>e.name;

type.typeParameters = concatenate(outerTypeParameters, localTypeParameters);

type.outerTypeParameters = outerTypeParameters;

type.localTypeParameters = localTypeParameters;

(<GenericType>type).target = <GenericType>type;

(<GenericType>type).typeArguments = type.typeParameters;

type.thisType = <TypeParameter>createType(TypeFlags.TypeParameter);

if (typeParameters) {

// Initialize the instantiation cache for generic type aliases. The declared type corresponds to

// an instantiation of the type alias with the type parameters supplied as type arguments.

}

}

else {

// these partial properties when identifying discriminant properties, but otherwise they are filtered out

// and do not appear to be present in the union type.

function getUnionOrIntersectionProperty(type: UnionOrIntersectionType, name: string): Symbol {

let property = properties.get(name);

if (!property) {

property = createUnionOrIntersectionProperty(type, name);

type.typeParameters = typeParameters;

type.outerTypeParameters = undefined;

type.localTypeParameters = typeParameters;

type.target = <GenericType>type;

type.typeArguments = type.typeParameters;

type.thisType = <TypeParameter>createType(TypeFlags.TypeParameter);

}

sourceStack[depth] = source;

targetStack[depth] = target;

depth++;

const saveExpandingFlags = expandingFlags;

if (!(expandingFlags & 1) && isDeeplyNestedGeneric(source, sourceStack, depth)) expandingFlags |= 1;

}

function transformTypeOfMembers(type: Type, f: (propertyType: Type) => Type) {

for (const property of getPropertiesOfObjectType(type)) {

const original = getTypeOfSymbol(property);

const updated = f(original);

let targetStack: Type[];

let depth = 0;

let inferiority = 0;

inferFromTypes(originalSource, originalTarget);

function isInProcess(source: Type, target: Type) {

// If we have previously computed the control flow type for the reference at

// this flow loop junction, return the cached type.

const id = getFlowNodeId(flow);

if (!key) {

key = getFlowCacheKey(reference);

}

// Grammar checking

checkGrammarObjectLiteralExpression(node, inDestructuringPattern);

const propertiesArray: Symbol[] = [];

const contextualType = getApparentTypeOfContextualType(node);

const contextualTypeHasPattern = contextualType && contextualType.pattern &&

const targetAttributesType = getJsxElementAttributesType(node);

// Process this array in right-to-left order so we know which

// attributes (mostly from spreads) are being overwritten and

// thus should have their types ignored

Property = Getter | Setter

}

for (const member of node.members) {

if (member.kind === SyntaxKind.Constructor) {

for (const param of (member as ConstructorDeclaration).parameters) {

}

function checkObjectTypeForDuplicateDeclarations(node: TypeLiteralNode | InterfaceDeclaration) {

for (const member of node.members) {

if (member.kind == SyntaxKind.PropertySignature) {

let memberName: string;

}

function getSymbolsInScope(location: Node, meaning: SymbolFlags): Symbol[] {

let memberFlags: ModifierFlags = ModifierFlags.None;

if (isInsideWithStatementBody(location)) {

}

function checkGrammarObjectLiteralExpression(node: ObjectLiteralExpression, inDestructuring: boolean) {

const Property = 1;

const GetAccessor = 2;

const SetAccessor = 4;

}

function checkGrammarJsxElement(node: JsxOpeningLikeElement) {

for (const attr of node.attributes) {

if (attr.kind === SyntaxKind.JsxSpreadAttribute) {

continue;