/**

* 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

} from "./program";

import {

FlowFlags,

Flow

} from "./flow";

import {

SignatureNode,

ParameterKind,

CommonTypeNode,

NodeKind,

TypeNode,

TypeName,

TypeParameterNode,

Node,

Range,

IdentifierExpression,

CallExpression,

ElementAccessExpression,

PropertyAccessExpression,

LiteralExpression,

LiteralKind,

ParenthesizedExpression,

AssertionExpression,

Expression,

IntegerLiteralExpression,

UnaryPrefixExpression,

UnaryPostfixExpression,

AssertionKind,

BinaryExpression,

ThisExpression,

SuperExpression,

isTypeOmitted

} from "./ast";

import {

Type,

Signature,

typesToString,

TypeKind,

TypeFlags

} from "./types";

import {

CommonFlags,

CommonSymbols

} from "./common";

import {

makeMap,

isPowerOf2

} from "./util";

import {

Token

} 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;

}

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

resolveType(

/** The type to resolve. */

node: CommonTypeNode,

/** Relative context. */

context: Element,

/** Type arguments inherited through context, i.e. `T`. */

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

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

reportMode: ReportMode = ReportMode.REPORT

): Type | null {

// handle signature

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

let explicitThisType = (<SignatureNode>node).explicitThisType;

let thisType: Type | null = null;

if (explicitThisType) {

thisType = this.resolveType(

explicitThisType,

context,

contextualTypeArguments,

reportMode

);

if (!thisType) return null;

}

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

let numParameters = parameterNodes.length;

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

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

let requiredParameters = 0;

let 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,

context,

contextualTypeArguments,

reportMode

);

if (!parameterType) return null;

parameterTypes[i] = parameterType;

parameterNames[i] = parameterNode.name.text;

}

let returnTypeNode = (<SignatureNode>node).returnType;

if (isTypeOmitted(returnTypeNode)) {

if (reportMode == ReportMode.REPORT) {

this.error(

DiagnosticCode.Type_expected,

returnTypeNode.range

);

}

return null;

}

let returnType: Type | null;

if (returnTypeNode) {

returnType = this.resolveType(

returnTypeNode,

context,

contextualTypeArguments,

reportMode

);

if (!returnType) return null;

} else {

returnType = Type.void;

}

let signature = new Signature(parameterTypes, returnType, thisType);

signature.parameterNames = parameterNames;

signature.requiredParameters = requiredParameters;

signature.hasRest = hasRest;

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

}

// now dealing with TypeNode

assert(node.kind == NodeKind.TYPE);

var typeNode = <TypeNode>node;

var typeName = typeNode.name;

var typeArgumentNodes = typeNode.typeArguments;

var possiblyPlaceholder = !typeName.next;

// look up in contextual type arguments if possibly a placeholder

if (possiblyPlaceholder) {

if (contextualTypeArguments && contextualTypeArguments.has(typeName.identifier.text)) {

let type = contextualTypeArguments.get(typeName.identifier.text)!;

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)) {

if (reportMode == ReportMode.REPORT) {

this.error(

DiagnosticCode.Basic_type_0_cannot_be_nullable,

node.range, type.toString()

);

}

}

return type.asNullable();

}

return type;

}

}

// look up in context

var element = this.resolveTypeName(typeName, context, 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

);

}

}

return Type.i32;

}

// handle classes

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

let instance = this.resolveClassInclTypeArguments(

<ClassPrototype>element,

typeArgumentNodes,

context,

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

node

); // reports

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,

typeNode.name.range, typeName.identifier.text

);

}

} else {

return type.asNullable();

}

}

return type;

}

// handle special native type

if (possiblyPlaceholder && typeName.identifier.text == CommonSymbols.native) {

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

if (reportMode == ReportMode.REPORT) {

this.error(

DiagnosticCode.Expected_0_type_arguments_but_got_1,

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

);

}

return null;

}

let typeArgument = this.resolveType(

typeArgumentNodes[0],

context,

contextualTypeArguments,

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);

}

}

// resolve normally

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

let typeArguments: Type[] | null = null;

if (typeParameterNodes) {

typeArguments = this.resolveTypeArguments(

typeParameterNodes,

typeArgumentNodes,

context,

contextualTypeArguments = makeMap(contextualTypeArguments), // inherit

node,

reportMode

);

if (!typeArguments) return null;

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

this.error(

DiagnosticCode.Type_0_is_not_generic,

typeNode.range, typeName.identifier.text

);

// recoverable

}

let type = this.resolveType(

(<TypeDefinition>element).typeNode,

element,

contextualTypeArguments,

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,

typeNode.name.range, typeName.identifier.text

);

}

} else {

return type.asNullable();

}

}

return type;

}

if (reportMode == ReportMode.REPORT) {

this.error(

DiagnosticCode.Cannot_find_name_0,

typeNode.name.range, typeName.identifier.text

);

}

return null;

}

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

resolveTypeName(

/** The type name to resolve. */

typeName: TypeName,

/** Relative context. */

context: Element,

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

reportMode = ReportMode.REPORT

): Element | null {

var element = context.lookup(typeName.identifier.text);

if (!element) {

if (reportMode == ReportMode.REPORT) {

this.error(

DiagnosticCode.Cannot_find_name_0,

typeName.range, typeName.identifier.text

);

}

return null;

}

var prev = typeName;

var next = typeName.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(

/** Actual type parameter nodes. */

typeParameters: TypeParameterNode[],

/** Type arguments provided. */

typeArgumentNodes: CommonTypeNode[] | null,

/** Relative context. */

context: Element,

/** Type arguments inherited through context, i.e. `T`. */

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

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

alternativeReportNode: Node | null = null,

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

reportMode: ReportMode = ReportMode.REPORT

): Type[] | null {

var minParameterCount = 0;

var maxParameterCount = 0;

for (let i = 0; i < typeParameters.length; ++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(

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

(<TypeNode[]>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

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

context,

contextualTypeArguments,

reportMode

)

: this.resolveType( // reports

assert(typeParameters[i].defaultType),

context,

contextualTypeArguments,

reportMode

);

if (!type) return null;

// TODO: check extendsType

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

typeArguments[i] = type;

}

return typeArguments;

}

/** Resolves an identifier to the program element it refers to. */

resolveIdentifier(

/** The expression to resolve. */

identifier: IdentifierExpression,

/** Optional flow to search for scoped locals. */

flow: Flow | null,

/** Optional context to search. */

context: Element | null,

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

reportMode: ReportMode = ReportMode.REPORT

): Element | null {

var name = identifier.text;

var element: Element | null;

if (flow) {

if (element = flow.lookup(name)) {

this.currentThisExpression = null;

this.currentElementExpression = null;

return element;

}

}

if (context) {

if (element = context.lookup(name)) {

this.currentThisExpression = null;

this.currentElementExpression = null;

return element;

}

}

if (element = this.program.lookupGlobal(name)) {

this.currentThisExpression = null;

this.currentElementExpression = null;

return element;

}

if (reportMode == ReportMode.REPORT) {

this.error(

DiagnosticCode.Cannot_find_name_0,

identifier.range, name

);

}

return null;

}

/** Resolves a lazily compiled global, i.e. a static class field. */

ensureResolvedLazyGlobal(global: Global, reportMode: ReportMode = ReportMode.REPORT): bool {

if (global.is(CommonFlags.RESOLVED)) return true;

var typeNode = global.typeNode;

if (!typeNode) return false;

var type = this.resolveType( // reports

typeNode,

global.parent,

null,

reportMode

);

if (!type) return false;

global.setType(type);

return true;

}

/** Resolves a property access expression to the program element it refers to. */

resolvePropertyAccessExpression(

/** The expression to resolve. */

propertyAccess: PropertyAccessExpression,

/** Current flow. */

flow: Flow,

/** Current contextual type. */

contextualType: Type,

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

reportMode: ReportMode = ReportMode.REPORT

): Element | null {

var targetExpression = propertyAccess.expression;

var target = this.resolveExpression(targetExpression, flow, contextualType, reportMode); // reports

if (!target) return null;

var propertyName = propertyAccess.property.text;

// Resolve variable-likes to their class type first

switch (target.kind) {

case ElementKind.GLOBAL: if (!this.ensureResolvedLazyGlobal(<Global>target, reportMode)) return null;

case ElementKind.LOCAL:

case ElementKind.FIELD: {

let type = (<VariableLikeElement>target).type; assert(type != Type.void);

let classReference = type.classReference;

if (!classReference) {

let typeClasses = this.program.typeClasses;

if (!type.is(TypeFlags.REFERENCE) && typeClasses.has(type.kind)) {

classReference = typeClasses.get(type.kind)!;

} else {

this.error(

DiagnosticCode.Property_0_does_not_exist_on_type_1,

propertyAccess.property.range, propertyName, (<VariableLikeElement>target).type.toString()

);

return null;

}

}

target = classReference;

break;

}

case ElementKind.PROPERTY_PROTOTYPE: { // static

let getterInstance = this.resolveFunction( // reports

assert((<PropertyPrototype>target).getterPrototype), // must have a getter

null,

makeMap<string,Type>(),

reportMode

);

if (!getterInstance) return null;

let classReference = getterInstance.signature.returnType.classReference;

if (!classReference) {

this.error(

DiagnosticCode.Property_0_does_not_exist_on_type_1,

propertyAccess.property.range, propertyName, getterInstance.signature.returnType.toString()

);

return null;

}

target = classReference;

break;

}

case ElementKind.PROPERTY: { // instance

let getterInstance = assert((<Property>target).getterInstance); // must have a getter

let classReference = getterInstance.signature.returnType.classReference;

if (!classReference) {

this.error(

DiagnosticCode.Property_0_does_not_exist_on_type_1,

propertyAccess.property.range, propertyName, getterInstance.signature.returnType.toString()

);

return null;

}

target = classReference;

break;

}

case ElementKind.CLASS: { // property access on element access?

let elementExpression = this.currentElementExpression;

if (elementExpression) {

// let arrayType = this.program.determineBuiltinArrayType(<Class>target);

// if (!arrayType) {

let indexedGet = (<Class>target).lookupOverload(OperatorKind.INDEXED_GET);

if (!indexedGet) {

this.error(

DiagnosticCode.Index_signature_is_missing_in_type_0,

elementExpression.range, (<Class>target).internalName

);

return null;

}

let arrayType = indexedGet.signature.returnType;

// }

if (!(target = arrayType.classReference)) {

this.error(

DiagnosticCode.Property_0_does_not_exist_on_type_1,

propertyAccess.property.range, propertyName, arrayType.toString()

);

return null;

}

}

break;

}

case ElementKind.FUNCTION_PROTOTYPE: { // function Symbol() + type Symbol = _Symbol

let shadowType = target.shadowType;

if (shadowType) {

if (!shadowType.is(CommonFlags.RESOLVED)) {

let resolvedType = this.resolveType(shadowType.typeNode, shadowType.parent, null, reportMode);

if (resolvedType) shadowType.setType(resolvedType);

}

let classReference = shadowType.type.classReference;

if (classReference) target = classReference.prototype;

break;

}

}

}

// Look up the member within

switch (target.kind) {

case ElementKind.CLASS_PROTOTYPE:

case ElementKind.CLASS: {

do {

let members = target.members;

if (members && members.has(propertyName)) {

this.currentThisExpression = targetExpression;

this.currentElementExpression = null;

return members.get(propertyName)!; // instance FIELD, static GLOBAL, FUNCTION_PROTOTYPE...

}

// traverse inherited static members on the base prototype if target is a class prototype

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

if ((<ClassPrototype>target).basePrototype) {

target = <ClassPrototype>(<ClassPrototype>target).basePrototype;

} else {

break;

}

// traverse inherited instance members on the base class if target is a class instance

} else if (target.kind == ElementKind.CLASS) {

if ((<Class>target).base) {

target = <Class>(<Class>target).base;

} else {

break;

}

} else {

break;

}

} while (true);

break;

}

default: { // enums or other namespace-like elements

let members = target.members;

if (members && members.has(propertyName)) {

this.currentThisExpression = targetExpression;

this.currentElementExpression = null;

return members.get(propertyName)!; // static ENUMVALUE, static GLOBAL, static FUNCTION_PROTOTYPE...

}

break;

}

}

this.error(

DiagnosticCode.Property_0_does_not_exist_on_type_1,

propertyAccess.property.range, propertyName, target.internalName

);

return null;

}

/** Resolves an element access expression to the program element it refers to. */

resolveElementAccessExpression(

/** The expression to resolve. */

elementAccess: ElementAccessExpression,

/** Current flow. */

flow: Flow,

/** Current contextual type. */

contextualType: Type,

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

reportMode: ReportMode = ReportMode.REPORT

): Element | null {

var targetExpression = elementAccess.expression;

var target = this.resolveExpression(targetExpression, flow, contextualType, reportMode); // reports

if (!target) return null;

switch (target.kind) {

case ElementKind.GLOBAL: if (!this.ensureResolvedLazyGlobal(<Global>target, reportMode)) return null;

case ElementKind.LOCAL:

case ElementKind.FIELD: {

let type = (<VariableLikeElement>target).type;

if (target = type.classReference) {

this.currentThisExpression = targetExpression;

this.currentElementExpression = elementAccess.elementExpression;

return target;

}

break;

}

case ElementKind.CLASS: {

// let arrayType = this.program.determineBuiltinArrayType(<Class>target);

// if (!arrayType) {

let indexedGet = (<Class>target).lookupOverload(OperatorKind.INDEXED_GET);

if (!indexedGet) {

if (reportMode == ReportMode.REPORT) {

this.error(

DiagnosticCode.Index_signature_is_missing_in_type_0,

elementAccess.range, (<Class>target).internalName

);

}

return null;

}

let arrayType = indexedGet.signature.returnType;

// }

if (targetExpression.kind == NodeKind.ELEMENTACCESS) { // nested element access

if (target = arrayType.classReference) {

this.currentThisExpression = targetExpression;

this.currentElementExpression = elementAccess.elementExpression;

return target;

}

return null;

}

this.currentThisExpression = targetExpression;

this.currentElementExpression = elementAccess.elementExpression;

return target;

}

}

if (reportMode == ReportMode.REPORT) {

this.error(

DiagnosticCode.Operation_not_supported,

targetExpression.range

);

}

return null;

}

/** Determines the final type of an integer literal given the specified contextual type. */

determineIntegerLiteralType(

/** Integer literal value. */

intValue: I64,

/** Current contextual type. */

contextualType: Type

): Type {

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

// compile to contextualType if matching

switch (contextualType.kind) {

case TypeKind.I8: {

if (i64_is_i8(intValue)) return Type.i8;

break;

}

case TypeKind.U8: {

if (i64_is_u8(intValue)) return Type.u8;

break;

}

case TypeKind.I16: {

if (i64_is_i16(intValue)) return Type.i16;

break;

}

case TypeKind.U16: {

if (i64_is_u16(intValue)) return Type.u16;

break;

}

case TypeKind.I32: {

if (i64_is_i32(intValue)) return Type.i32;

break;

}

case TypeKind.U32: {

if (i64_is_u32(intValue)) return Type.u32;

break;

}

case TypeKind.BOOL: {

if (i64_is_bool(intValue)) return Type.bool;

break;

}

case TypeKind.ISIZE: {

if (!this.program.options.isWasm64) {

if (i64_is_i32(intValue)) return Type.isize32;

break;

}

return Type.isize64;

}

case TypeKind.USIZE: {

if (!this.program.options.isWasm64) {

if (i64_is_u32(intValue)) return Type.usize32;

break;

}

return Type.usize64;

}

case TypeKind.I64: return Type.i64;

case TypeKind.U64: return Type.u64;

case TypeKind.F32: return Type.f32;

case TypeKind.F64: return Type.f64;

case TypeKind.VOID: break; // best fitting below

default: assert(false);

}

}

// otherwise compile to best fitting native type

if (i64_is_i32(intValue)) return Type.i32;

if (i64_is_u32(intValue)) return Type.u32;

return Type.i64;

}

/** Resolves any expression to the program element it refers to. */

resolveExpression(

/** The expression to resolve. */

expression: Expression,

/** Current flow. */

flow: Flow,

/** Current contextual type. */

contextualType: Type = Type.void,

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

reportMode: ReportMode = ReportMode.REPORT

): Element | null {

while (expression.kind == NodeKind.PARENTHESIZED) { // simply skip

expression = (<ParenthesizedExpression>expression).expression;

}

switch (expression.kind) {

case NodeKind.ASSERTION: {

return this.resolveAssertionExpression(

<AssertionExpression>expression,

flow, contextualType, reportMode

);

}

case NodeKind.UNARYPREFIX: {

return this.resolveUnaryPrefixExpression(

<UnaryPrefixExpression>expression,

flow, contextualType, reportMode

);

}

case NodeKind.UNARYPOSTFIX: {

return this.resolveUnaryPostfixExpression(

<UnaryPostfixExpression>expression,

flow, contextualType, reportMode

);

}

case NodeKind.BINARY: {

return this.resolveBinaryExpression(

<BinaryExpression>expression,

flow, contextualType, reportMode

);

}

case NodeKind.THIS: {

return this.resolveThisExpression(

<ThisExpression>expression,

flow, contextualType, reportMode

);

}

case NodeKind.SUPER: {

return this.resolveSuperExpression(

<SuperExpression>expression,

flow, contextualType, reportMode

);

}

case NodeKind.IDENTIFIER: {

return this.resolveIdentifier(

<IdentifierExpression>expression,

flow, flow.actualFunction, reportMode

);

}

case NodeKind.LITERAL: {

return this.resolveLiteralExpression(

<LiteralExpression>expression,

flow, contextualType, reportMode

);

}

case NodeKind.PROPERTYACCESS: {

return this.resolvePropertyAccessExpression(

<PropertyAccessExpression>expression,

flow, contextualType, reportMode

);

}

case NodeKind.ELEMENTACCESS: {

return this.resolveElementAccessExpression(

<ElementAccessExpression>expression,

flow, contextualType, reportMode

);

}

case NodeKind.CALL: {

return this.resolveCallExpression(

<CallExpression>expression,

flow, contextualType, reportMode

);

}

// TODO: everything else

}

if (reportMode == ReportMode.REPORT) {

this.error(

DiagnosticCode.Operation_not_supported,

expression.range

);

}

return null;

}

/** Resolves an assertion expression to the program element it refers to. */

resolveAssertionExpression(

/** The expression to resolve. */

expression: AssertionExpression,

/** Current flow. */

flow: Flow,

/** Current contextual type. */

contextualType: Type = Type.void,

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

reportMode: ReportMode = ReportMode.REPORT

): Element | null {

if (expression.assertionKind == AssertionKind.NONNULL) {

return this.resolveExpression(

expression.expression,

flow,

contextualType,

reportMode

);

}

var type = this.resolveType(

assert(expression.toType), // must be set if not NONNULL

flow.actualFunction,

flow.contextualTypeArguments,

reportMode

);

if (!type) return null;

var element: Element | null = type.classReference;

if (!element) {

let signature = type.signatureReference;

if (!signature) return null;

element = signature.asFunctionTarget(this.program);

}

this.currentThisExpression = null;

this.currentElementExpression = null;

return element;

}

/** Resolves an unary prefix expression to the program element it refers to. */

resolveUnaryPrefixExpression(

/** The expression to resolve. */

expression: UnaryPrefixExpression,

/** Current flow. */

flow: Flow,

/** Current contextual type. */

contextualType: Type = Type.void,

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

reportMode: ReportMode = ReportMode.REPORT

): Element | null {

var operand = expression.operand;

// TODO: operator overloads

switch (expression.operator) {

case Token.MINUS: {

// implicitly negate if an integer literal to distinguish between i32/u32/i64

if (operand.kind == NodeKind.LITERAL && (<LiteralExpression>operand).literalKind == LiteralKind.INTEGER) {

let type = this.determineIntegerLiteralType(

i64_sub(i64_zero, (<IntegerLiteralExpression>operand).value),

contextualType

);

let typeClasses = this.program.typeClasses;

return typeClasses.has(type.kind) ? typeClasses.get(type.kind)! : null;

}

return this.resolveExpression(

operand,

flow,