/**

* Resolve infrastructure to obtain types and elements.

* @module resolver

*//***/

import {

DiagnosticEmitter,

DiagnosticCode

} from "./diagnostics";

import {

Program,

ElementKind,

OperatorKind,

Element,

Class,

ClassPrototype,

Function,

FunctionPrototype,

VariableLikeElement,

Property,

PropertyPrototype,

Field,

FieldPrototype,

Global,

TypeDefinition,

TypedElement,

FunctionTarget,

IndexSignature,

isTypedElement

} from "./program";

import {

FlowFlags,

Flow

} from "./flow";

import {

FunctionTypeNode,

ParameterKind,

TypeNode,

NodeKind,

NamedTypeNode,

TypeName,

TypeParameterNode,

Node,

Range,

IdentifierExpression,

CallExpression,

ElementAccessExpression,

PropertyAccessExpression,

LiteralExpression,

LiteralKind,

ParenthesizedExpression,

AssertionExpression,

Expression,

IntegerLiteralExpression,

UnaryPrefixExpression,

UnaryPostfixExpression,

AssertionKind,

BinaryExpression,

ThisExpression,

SuperExpression,

CommaExpression,

InstanceOfExpression,

TernaryExpression,

isTypeOmitted,

FunctionExpression,

NewExpression

} from "./ast";

import {

Type,

Signature,

typesToString,

TypeKind,

TypeFlags

} from "./types";

import {

CommonFlags,

CommonSymbols

} from "./common";

import {

makeMap,

isPowerOf2

} from "./util";

import {

Token,

operatorTokenToString

} from "./tokenizer";

import {

BuiltinSymbols

} from "./builtins";

/** Indicates whether errors are reported or not. */

export enum ReportMode {

/** Report errors. */

REPORT,

/** Swallow errors. */

SWALLOW

}

/** Provides tools to resolve types and expressions. */

export class Resolver extends DiagnosticEmitter {

/** The program this resolver belongs to. */

program: Program;

/** Target expression of the previously resolved property or element access. */

currentThisExpression: Expression | null = null;

/** Element expression of the previously resolved element access. */

currentElementExpression : Expression | null = null;

/** Constructs the resolver for the specified program. */

constructor(

/** The program to construct a resolver for. */

program: Program

) {

super(program.diagnostics);

this.program = program;

}

// ====================================================== Types ======================================================

/** Resolves a {@link TypeNode} to a concrete {@link Type}. */

resolveType(

/** The type to resolve. */

node: TypeNode,

/** Contextual element. */

ctxElement: Element,

/** Contextual types, i.e. `T`. */

ctxTypes: Map<string,Type> | null = null,

/** How to proceed with eventual diagnostics. */

reportMode: ReportMode = ReportMode.REPORT

): Type | null {

switch (node.kind) {

case NodeKind.NAMEDTYPE: {

return this.resolveNamedType(

<NamedTypeNode>node,

ctxElement,

ctxTypes,

reportMode

);

}

case NodeKind.FUNCTIONTYPE: {

return this.resolveFunctionType(

<FunctionTypeNode>node,

ctxElement,

ctxTypes,

reportMode

);

}

default: assert(false);

}

return null;

}

/** Resolves a {@link NamedTypeNode} to a concrete {@link Type}. */

private resolveNamedType(

/** The type to resolve. */

node: NamedTypeNode,

/** Contextual element. */

ctxElement: Element,

/** Contextual types, i.e. `T`. */

ctxTypes: Map<string,Type> | null = null,

/** How to proceed with eventual diagnostics. */

reportMode: ReportMode = ReportMode.REPORT

): Type | null {

var nameNode = node.name;

var typeArgumentNodes = node.typeArguments;

var isSimpleType = !nameNode.next;

// Look up in contextual types if a simple type

if (isSimpleType) {

let simpleName = nameNode.identifier.text;

if (ctxTypes !== null && ctxTypes.has(simpleName)) {

let type = ctxTypes.get(simpleName)!;

if (typeArgumentNodes !== null && typeArgumentNodes.length) {

if (reportMode == ReportMode.REPORT) {

this.error(

DiagnosticCode.Type_0_is_not_generic,

node.range, type.toString()

);

}

}

if (node.isNullable) {

if (type.is(TypeFlags.REFERENCE)) return type.asNullable();

if (reportMode == ReportMode.REPORT) {

this.error(

DiagnosticCode.Basic_type_0_cannot_be_nullable,

node.range, type.toString()

);

}

}

return type;

}

}

// Look up in context

var element = this.resolveTypeName(nameNode, ctxElement, reportMode);

if (!element) return null;

// Use shadow type if present (i.e. namespace sharing a type)

if (element.shadowType) {

element = element.shadowType;

} else {

// Handle enums (become i32)

if (element.kind == ElementKind.ENUM) {

if (typeArgumentNodes !== null && typeArgumentNodes.length) {

if (reportMode == ReportMode.REPORT) {

this.error(

DiagnosticCode.Type_0_is_not_generic,

node.range, element.internalName

);

}

}

if (node.isNullable) {

if (reportMode == ReportMode.REPORT) {

this.error(

DiagnosticCode.Basic_type_0_cannot_be_nullable,

node.range, element.name + "/i32"

);

}

}

return Type.i32;

}

// Handle classes

if (element.kind == ElementKind.CLASS_PROTOTYPE) {

let instance = this.resolveClassInclTypeArguments(

<ClassPrototype>element,

typeArgumentNodes,

ctxElement,

makeMap<string,Type>(ctxTypes), // don't inherit

node,

reportMode

);

if (!instance) return null;

return node.isNullable ? instance.type.asNullable() : instance.type;

}

}

// Handle type definitions

if (element.kind == ElementKind.TYPEDEFINITION) {

// Shortcut already resolved (mostly builtins)

if (element.is(CommonFlags.RESOLVED)) {

if (typeArgumentNodes !== null && typeArgumentNodes.length) {

if (reportMode == ReportMode.REPORT) {

this.error(

DiagnosticCode.Type_0_is_not_generic,

node.range, element.internalName

);

}

}

let type = (<TypeDefinition>element).type;

if (node.isNullable) {

if (!type.is(TypeFlags.REFERENCE)) {

if (reportMode == ReportMode.REPORT) {

this.error(

DiagnosticCode.Basic_type_0_cannot_be_nullable,

nameNode.range, nameNode.identifier.text

);

}

} else {

return type.asNullable();

}

}

return type;

}

// Handle special built-in types

if (isSimpleType) {

switch (nameNode.identifier.symbol) {

case CommonSymbols.native: return this.resolveBuiltinNativeType(node, ctxElement, ctxTypes, reportMode);

case CommonSymbols.indexof: return this.resolveBuiltinIndexofType(node, ctxElement, ctxTypes, reportMode);

case CommonSymbols.valueof: return this.resolveBuiltinValueofType(node, ctxElement, ctxTypes, reportMode);

case CommonSymbols.returnof: return this.resolveBuiltinReturnTypeType(node, ctxElement, ctxTypes, reportMode);

}

}

// Resolve normally

let typeParameterNodes = (<TypeDefinition>element).typeParameterNodes;

let typeArguments: Type[] | null = null;

if (typeParameterNodes) {

typeArguments = this.resolveTypeArguments(

typeParameterNodes,

typeArgumentNodes,

ctxElement,

ctxTypes = makeMap(ctxTypes), // inherit

node,

reportMode

);

if (!typeArguments) return null;

} else if (typeArgumentNodes && typeArgumentNodes.length) {

this.error(

DiagnosticCode.Type_0_is_not_generic,

node.range, nameNode.identifier.text

);

}

let type = this.resolveType(

(<TypeDefinition>element).typeNode,

element,

ctxTypes,

reportMode

);

if (!type) return null;

if (node.isNullable) {

if (!type.is(TypeFlags.REFERENCE)) {

if (reportMode == ReportMode.REPORT) {

this.error(

DiagnosticCode.Basic_type_0_cannot_be_nullable,

nameNode.range, nameNode.identifier.text

);

}

} else {

return type.asNullable();

}

}

return type;

}

if (reportMode == ReportMode.REPORT) {

this.error(

DiagnosticCode.Cannot_find_name_0,

nameNode.range, nameNode.identifier.text

);

}

return null;

}

/** Resolves a {@link FunctionTypeNode} to a concrete {@link Type}. */

private resolveFunctionType(

/** The type to resolve. */

node: FunctionTypeNode,

/** Contextual element. */

ctxElement: Element,

/** Contextual types, i.e. `T`. */

ctxTypes: Map<string,Type> | null = null,

/** How to proceed with eventual diagnostics. */

reportMode: ReportMode = ReportMode.REPORT

): Type | null {

var explicitThisType = node.explicitThisType;

var thisType: Type | null = null;

if (explicitThisType) {

thisType = this.resolveType(

explicitThisType,

ctxElement,

ctxTypes,

reportMode

);

if (!thisType) return null;

}

var parameterNodes = node.parameters;

var numParameters = parameterNodes.length;

var parameterTypes = new Array<Type>(numParameters);

var parameterNames = new Array<string>(numParameters);

var requiredParameters = 0;

var hasRest = false;

for (let i = 0; i < numParameters; ++i) {

let parameterNode = parameterNodes[i];

switch (parameterNode.parameterKind) {

case ParameterKind.DEFAULT: {

requiredParameters = i + 1;

break;

}

case ParameterKind.REST: {

assert(i == numParameters);

hasRest = true;

break;

}

}

let parameterTypeNode = parameterNode.type;

if (isTypeOmitted(parameterTypeNode)) {

if (reportMode == ReportMode.REPORT) {

this.error(

DiagnosticCode.Type_expected,

parameterTypeNode.range

);

}

return null;

}

let parameterType = this.resolveType(

parameterTypeNode,

ctxElement,

ctxTypes,

reportMode

);

if (!parameterType) return null;

parameterTypes[i] = parameterType;

parameterNames[i] = parameterNode.name.text;

}

var returnTypeNode = node.returnType;

var returnType: Type | null;

if (isTypeOmitted(returnTypeNode)) {

if (reportMode == ReportMode.REPORT) {

this.error(

DiagnosticCode.Type_expected,

returnTypeNode.range

);

}

returnType = Type.void;

} else {

returnType = this.resolveType(

returnTypeNode,

ctxElement,

ctxTypes,

reportMode

);

if (!returnType) return null;

}

var signature = new Signature(this.program, parameterTypes, returnType, thisType);

signature.parameterNames = parameterNames;

signature.requiredParameters = requiredParameters;

signature.hasRest = hasRest;

return node.isNullable ? signature.type.asNullable() : signature.type;

}

private resolveBuiltinNativeType(

/** The type to resolve. */

node: NamedTypeNode,

/** Contextual element. */

ctxElement: Element,

/** Contextual types, i.e. `T`. */

ctxTypes: Map<string,Type> | null = null,

/** How to proceed with eventual diagnostics. */

reportMode: ReportMode = ReportMode.REPORT

): Type | null {

var typeArgumentNodes = node.typeArguments;

if (!(typeArgumentNodes && typeArgumentNodes.length == 1)) {

if (reportMode == ReportMode.REPORT) {

this.error(

DiagnosticCode.Expected_0_type_arguments_but_got_1,

node.range, "1", (typeArgumentNodes ? typeArgumentNodes.length : 1).toString(10)

);

}

return null;

}

var typeArgument = this.resolveType(typeArgumentNodes[0], ctxElement, ctxTypes, reportMode);

if (!typeArgument) return null;

switch (typeArgument.kind) {

case TypeKind.I8:

case TypeKind.I16:

case TypeKind.I32: return Type.i32;

case TypeKind.ISIZE: if (!this.program.options.isWasm64) return Type.i32;

case TypeKind.I64: return Type.i64;

case TypeKind.U8:

case TypeKind.U16:

case TypeKind.U32:

case TypeKind.BOOL: return Type.u32;

case TypeKind.USIZE: if (!this.program.options.isWasm64) return Type.u32;

case TypeKind.U64: return Type.u64;

case TypeKind.F32: return Type.f32;

case TypeKind.F64: return Type.f64;

case TypeKind.V128: return Type.v128;

case TypeKind.VOID: return Type.void;

default: assert(false);

}

return null;

}

private resolveBuiltinIndexofType(

/** The type to resolve. */

node: NamedTypeNode,

/** Contextual element. */

ctxElement: Element,

/** Contextual types, i.e. `T`. */

ctxTypes: Map<string,Type> | null = null,

/** How to proceed with eventual diagnostics. */

reportMode: ReportMode = ReportMode.REPORT

): Type | null {

var typeArgumentNodes = node.typeArguments;

if (!(typeArgumentNodes && typeArgumentNodes.length == 1)) {

if (reportMode == ReportMode.REPORT) {

this.error(

DiagnosticCode.Expected_0_type_arguments_but_got_1,

node.range, "1", (typeArgumentNodes ? typeArgumentNodes.length : 1).toString(10)

);

}

return null;

}

var typeArgument = this.resolveType(typeArgumentNodes[0], ctxElement, ctxTypes, reportMode);

if (!typeArgument) return null;

var classReference = typeArgument.classReference;

if (!classReference) {

if (reportMode == ReportMode.REPORT) {

this.error(

DiagnosticCode.Index_signature_is_missing_in_type_0,

typeArgumentNodes[0].range, typeArgument.toString()

);

}

return null;

}

var overload = classReference.lookupOverload(OperatorKind.INDEXED_GET);

if (overload) {

if (overload.is(CommonFlags.STATIC)) {

assert(overload.signature.parameterTypes.length == 2);

return overload.signature.parameterTypes[1];

} else {

assert(overload.signature.parameterTypes.length == 1);

return overload.signature.parameterTypes[0];

}

}

if (reportMode == ReportMode.REPORT) {

this.error(

DiagnosticCode.Index_signature_is_missing_in_type_0,

typeArgumentNodes[0].range, typeArgument.toString()

);

}

return null;

}

private resolveBuiltinValueofType(

/** The type to resolve. */

node: NamedTypeNode,

/** Contextual element. */

ctxElement: Element,

/** Contextual types, i.e. `T`. */

ctxTypes: Map<string,Type> | null = null,

/** How to proceed with eventual diagnostics. */

reportMode: ReportMode = ReportMode.REPORT

): Type | null {

var typeArgumentNodes = node.typeArguments;

if (!(typeArgumentNodes && typeArgumentNodes.length == 1)) {

if (reportMode == ReportMode.REPORT) {

this.error(

DiagnosticCode.Expected_0_type_arguments_but_got_1,

node.range, "1", (typeArgumentNodes ? typeArgumentNodes.length : 1).toString(10)

);

}

return null;

}

var typeArgument = this.resolveType(typeArgumentNodes[0], ctxElement, ctxTypes, reportMode);

if (!typeArgument) return null;

var classReference = typeArgument.classReference;

if (!classReference) {

if (reportMode == ReportMode.REPORT) {

this.error(

DiagnosticCode.Index_signature_is_missing_in_type_0,

typeArgumentNodes[0].range, typeArgument.toString()

);

}

return null;

}

var overload = classReference.lookupOverload(OperatorKind.INDEXED_GET);

if (overload) return overload.signature.returnType;

if (reportMode == ReportMode.REPORT) {

this.error(

DiagnosticCode.Index_signature_is_missing_in_type_0,

typeArgumentNodes[0].range, typeArgument.toString()

);

}

return null;

}

private resolveBuiltinReturnTypeType(

/** The type to resolve. */

node: NamedTypeNode,

/** Contextual element. */

ctxElement: Element,

/** Contextual types, i.e. `T`. */

ctxTypes: Map<string,Type> | null = null,

/** How to proceed with eventualy diagnostics. */

reportMode: ReportMode = ReportMode.REPORT

): Type | null {

var typeArgumentNodes = node.typeArguments;

if (!(typeArgumentNodes && typeArgumentNodes.length == 1)) {

if (reportMode == ReportMode.REPORT) {

this.error(

DiagnosticCode.Expected_0_type_arguments_but_got_1,

node.range, "1", (typeArgumentNodes ? typeArgumentNodes.length : 1).toString(10)

);

}

return null;

}

var typeArgument = this.resolveType(typeArgumentNodes[0], ctxElement, ctxTypes, reportMode);

if (!typeArgument) return null;

var signatureReference = typeArgument.signatureReference;

if (!signatureReference) {

if (reportMode == ReportMode.REPORT) {

this.error(

DiagnosticCode.Type_0_has_no_call_signatures,

typeArgumentNodes[0].range, typeArgument.toString()

);

}

return null;

}

return signatureReference.returnType;

}

/** Resolves a type name to the program element it refers to. */

resolveTypeName(

/** The type name to resolve. */

node: TypeName,

/** Contextual element. */

ctxElement: Element,

/** How to proceed with eventual diagnostics. */

reportMode = ReportMode.REPORT

): Element | null {

var element = ctxElement.lookup(node.identifier.text);

if (!element) {

if (reportMode == ReportMode.REPORT) {

this.error(

DiagnosticCode.Cannot_find_name_0,

node.range, node.identifier.text

);

}

return null;

}

var prev = node;

var next = node.next;

while (next) {

if (!(element = element.lookupInSelf(next.identifier.text))) {

if (reportMode == ReportMode.REPORT) {

this.error(

DiagnosticCode.Property_0_does_not_exist_on_type_1,

next.range, next.identifier.text, prev.identifier.text

);

}

return null;

}

prev = next;

next = next.next;

}

return element;

}

/** Resolves an array of type arguments to concrete types. */

resolveTypeArguments(

/** Type parameter nodes present. */

typeParameters: TypeParameterNode[],

/** Type argument nodes provided. */

typeArgumentNodes: TypeNode[] | null,

/** Contextual element. */

ctxElement: Element,

/** Contextual types, i.e. `T`. */

ctxTypes: Map<string,Type> = makeMap<string,Type>(),

/** Alternative report node in case of empty type arguments. */

alternativeReportNode: Node | null = null,

/** How to proceed with eventual diagnostics. */

reportMode: ReportMode = ReportMode.REPORT

): Type[] | null {

var minParameterCount = 0;

var maxParameterCount = 0;

for (let i = 0, k = typeParameters.length; i < k; ++i) {

if (!typeParameters[i].defaultType) ++minParameterCount;

++maxParameterCount;

}

var argumentCount = typeArgumentNodes ? typeArgumentNodes.length : 0;

if (argumentCount < minParameterCount || argumentCount > maxParameterCount) {

this.error(

DiagnosticCode.Expected_0_type_arguments_but_got_1,

argumentCount

? Range.join(

(<NamedTypeNode[]>typeArgumentNodes)[0].range,

(<NamedTypeNode[]>typeArgumentNodes)[argumentCount - 1].range

)

: assert(alternativeReportNode).range,

(argumentCount < minParameterCount ? minParameterCount : maxParameterCount).toString(10),

argumentCount.toString(10)

);

return null;

}

var typeArguments = new Array<Type>(maxParameterCount);

for (let i = 0; i < maxParameterCount; ++i) {

let type = i < argumentCount

? this.resolveType( // reports

(<NamedTypeNode[]>typeArgumentNodes)[i],

ctxElement,

ctxTypes,

reportMode

)

: this.resolveType( // reports

assert(typeParameters[i].defaultType),

ctxElement,

ctxTypes,

reportMode

);

if (!type) return null;

// TODO: check extendsType

ctxTypes.set(typeParameters[i].name.text, type);

typeArguments[i] = type;

}

return typeArguments;

}

/** Resolves respectively infers the concrete instance of a function by call context. */

maybeInferCall(

node: CallExpression,

prototype: FunctionPrototype,

ctxFlow: Flow,

reportMode: ReportMode = ReportMode.REPORT

): Function | null {

var typeArguments = node.typeArguments;

// resolve generic call if type arguments have been provided

if (typeArguments) {

if (!prototype.is(CommonFlags.GENERIC)) {

if (reportMode == ReportMode.REPORT) {

this.error(

DiagnosticCode.Type_0_is_not_generic,

node.expression.range, prototype.internalName

);

}

return null;

}

return this.resolveFunctionInclTypeArguments(

prototype,

node.typeArguments,

ctxFlow.actualFunction,

makeMap(ctxFlow.contextualTypeArguments), // don't inherit

node,

reportMode

);

}

// infer generic call if type arguments have been omitted

if (prototype.is(CommonFlags.GENERIC)) {

let contextualTypeArguments = makeMap<string,Type>(ctxFlow.contextualTypeArguments);

// fill up contextual types with auto for each generic component

let typeParameterNodes = assert(prototype.typeParameterNodes);

let numTypeParameters = typeParameterNodes.length;

let typeParameterNames = new Set<string>();

for (let i = 0; i < numTypeParameters; ++i) {

let name = typeParameterNodes[i].name.text;

contextualTypeArguments.set(name, Type.auto);

typeParameterNames.add(name);

}

let parameterNodes = prototype.functionTypeNode.parameters;

let numParameters = parameterNodes.length;

let argumentNodes = node.arguments;

let numArguments = argumentNodes.length;

// infer types with generic components while updating contextual types

for (let i = 0; i < numParameters; ++i) {

let argumentExpression = i < numArguments ? argumentNodes[i] : parameterNodes[i].initializer;

if (!argumentExpression) { // missing initializer -> too few arguments

if (reportMode == ReportMode.REPORT) {

this.error(

DiagnosticCode.Expected_0_arguments_but_got_1,

node.range, numParameters.toString(10), numArguments.toString(10)

);

}

return null;

}

let typeNode = parameterNodes[i].type;

if (typeNode.hasGenericComponent(typeParameterNodes)) {

let type = this.resolveExpression(argumentExpression, ctxFlow, Type.auto, ReportMode.SWALLOW);

if (type) this.propagateInferredGenericTypes(typeNode, type, ctxFlow, contextualTypeArguments, typeParameterNames);

}

}

// apply concrete types to the generic function signature

let resolvedTypeArguments = new Array<Type>(numTypeParameters);

for (let i = 0; i < numTypeParameters; ++i) {

let name = typeParameterNodes[i].name.text;

if (contextualTypeArguments.has(name)) {

let inferredType = contextualTypeArguments.get(name)!;

if (inferredType != Type.auto) {

resolvedTypeArguments[i] = inferredType;

continue;

}

}

// unused template, e.g. `function test<T>(): void {...}` called as `test()`

// invalid because the type is effectively unknown inside the function body

if (reportMode == ReportMode.REPORT) {

this.error(

DiagnosticCode.Type_argument_expected,

node.expression.range.atEnd

);

}

return null;

}

return this.resolveFunction(

prototype,

resolvedTypeArguments,

makeMap<string,Type>(ctxFlow.contextualTypeArguments),

reportMode

);

}

// otherwise resolve the non-generic call as usual

return this.resolveFunction(prototype, null, makeMap<string,Type>(), reportMode);

}

/** Updates contextual types with a possibly encapsulated inferred type. */

private propagateInferredGenericTypes(

/** The inferred type node. */

node: TypeNode,

/** The inferred type. */

type: Type,

/** Contextual flow. */

ctxFlow: Flow,

/** Contextual types, i.e. `T`, with unknown types initialized to `auto`. */

ctxTypes: Map<string,Type>,

/** The names of the type parameters being inferred. */

typeParameterNames: Set<string>

): void {

if (node.kind == NodeKind.NAMEDTYPE) {

let typeArgumentNodes = (<NamedTypeNode>node).typeArguments;

if (typeArgumentNodes !== null && typeArgumentNodes.length) { // foo<T>(bar: Array<T>)

let classReference = type.classReference;

if (classReference) {

let classPrototype = this.resolveTypeName((<NamedTypeNode>node).name, ctxFlow.actualFunction);

if (!classPrototype || classPrototype.kind != ElementKind.CLASS_PROTOTYPE) return;

if (classReference.prototype == <ClassPrototype>classPrototype) {

let typeArguments = classReference.typeArguments;

if (typeArguments !== null && typeArguments.length == typeArgumentNodes.length) {

for (let i = 0, k = typeArguments.length; i < k; ++i) {

this.propagateInferredGenericTypes(typeArgumentNodes[i], typeArguments[i], ctxFlow, ctxTypes, typeParameterNames);

}

return;

}

}

}

} else { // foo<T>(bar: T)

let name = (<NamedTypeNode>node).name.identifier.text;

if (ctxTypes.has(name)) {

let currentType = ctxTypes.get(name)!;

if (currentType == Type.auto || (typeParameterNames.has(name) && currentType.isAssignableTo(type))) {

ctxTypes.set(name, type);

}

}

}

} else if (node.kind == NodeKind.FUNCTIONTYPE) { // foo<T>(bar: (baz: T) => i32))

let parameterNodes = (<FunctionTypeNode>node).parameters;

if (parameterNodes !== null && parameterNodes.length) {

let signatureReference = type.signatureReference;

if (signatureReference) {

let parameterTypes = signatureReference.parameterTypes;

let thisType = signatureReference.thisType;

if (parameterTypes.length == parameterNodes.length && !thisType == !(<FunctionTypeNode>node).explicitThisType) {

for (let i = 0, k = parameterTypes.length; i < k; ++i) {

this.propagateInferredGenericTypes(parameterNodes[i].type, parameterTypes[i], ctxFlow, ctxTypes, typeParameterNames);

}

this.propagateInferredGenericTypes((<FunctionTypeNode>node).returnType, signatureReference.returnType, ctxFlow, ctxTypes, typeParameterNames);

if (thisType) this.propagateInferredGenericTypes((<FunctionTypeNode>node).explicitThisType!, thisType, ctxFlow, ctxTypes, typeParameterNames);

return;

}

}

}

}

}

/** Gets the concrete type of an element. */

getTypeOfElement(element: Element): Type | null {

var kind = element.kind;

if (kind == ElementKind.GLOBAL) {

if (!this.ensureResolvedLazyGlobal(<Global>element, ReportMode.SWALLOW)) return null;

}

if (isTypedElement(kind)) {

let type = (<TypedElement>element).type;

assert(type != Type.void);

let classReference = type.classReference;

if (classReference) {

let wrappedType = classReference.wrappedType;

if (wrappedType) type = wrappedType;

}

return type;

}

if (kind == ElementKind.FUNCTION_TARGET) return (<FunctionTarget>element).type;

return null;

}

/** Gets the element of a concrete type. */

getElementOfType(type: Type): Element | null {

if (type.is(TypeFlags.REFERENCE)) {

let classReference = type.classReference;

if (classReference) return classReference;

let signatureReference = assert(type.signatureReference);

return signatureReference.asFunctionTarget(this.program);

} else if (type != Type.void) {

let wrapperClasses = this.program.wrapperClasses;

assert(wrapperClasses.has(type));

return wrapperClasses.get(type)!;

}

return null;

}

// =================================================== Expressions ===================================================

/** Looks up the program element the specified expression refers to. */

lookupExpression(

/** The expression to look up. */

node: Expression,

/** Contextual flow. */

ctxFlow: Flow,

/** Contextual type. */

ctxType: Type = Type.auto,

/** How to proceed with eventual diagnostics. */

reportMode: ReportMode = ReportMode.REPORT

): Element | null {

while (node.kind == NodeKind.PARENTHESIZED) { // skip

node = (<ParenthesizedExpression>node).expression;

}

switch (node.kind) {

case NodeKind.ASSERTION: {

return this.lookupAssertionExpression(

<AssertionExpression>node,

ctxFlow, ctxType, reportMode

);

}

case NodeKind.BINARY: {

return this.lookupBinaryExpression(

<BinaryExpression>node,

ctxFlow, ctxType, reportMode

);

}

case NodeKind.CALL: {

return this.lookupCallExpression(

<CallExpression>node,

ctxFlow, ctxType, reportMode

);

}

case NodeKind.COMMA: {

return this.lookupCommaExpression(

<CommaExpression>node,

ctxFlow, ctxType, reportMode

);

}

case NodeKind.ELEMENTACCESS: {

return this.lookupElementAccessExpression(

<ElementAccessExpression>node,

ctxFlow, ctxType, reportMode

);

}

case NodeKind.FUNCTION: {

return this.lookupFunctionExpression(

<FunctionExpression>node,

ctxFlow, ctxType, reportMode

);

}

case NodeKind.IDENTIFIER:

case NodeKind.FALSE:

case NodeKind.NULL:

case NodeKind.TRUE: {

return this.lookupIdentifierExpression(

<IdentifierExpression>node,

ctxFlow, ctxFlow.actualFunction, reportMode

);

}

case NodeKind.THIS: {

return this.lookupThisExpression(

<ThisExpression>node,

ctxFlow, ctxType, reportMode

);

}

case NodeKind.SUPER: {

return this.lookupSuperExpression(

<SuperExpression>node,

ctxFlow, ctxType, reportMode

);

}

case NodeKind.INSTANCEOF: {

return this.lookupInstanceOfExpression(

<InstanceOfExpression>node,

ctxFlow, ctxType, reportMode

);

}

case NodeKind.LITERAL: {

return this.lookupLiteralExpression(

<LiteralExpression>node,

ctxFlow, ctxType, reportMode

);

}

case NodeKind.NEW: {

return this.lookupNewExpression(

<NewExpression>node,

ctxFlow, ctxType, reportMode

);

}

case NodeKind.PROPERTYACCESS: {

return this.lookupPropertyAccessExpression(

<PropertyAccessExpression>node,

ctxFlow, ctxType, reportMode

);

}

case NodeKind.TERNARY: {

return this.lookupTernaryExpression(

<TernaryExpression>node,

ctxFlow, ctxType, reportMode

);

}

case NodeKind.UNARYPOSTFIX: {

return this.lookupUnaryPostfixExpression(

<UnaryPostfixExpression>node,

ctxFlow, ctxType, reportMode

);

}

case NodeKind.UNARYPREFIX: {

return this.lookupUnaryPrefixExpression(

<UnaryPrefixExpression>node,