/**

* AssemblyScript's intermediate representation describing a program's elements.

* @module program

*//***/

import {

CommonFlags,

STATIC_DELIMITER,

INSTANCE_DELIMITER,

LIBRARY_PREFIX,

GETTER_PREFIX,

SETTER_PREFIX,

FILESPACE_PREFIX

} from "./common";

import {

Options,

Feature

} from "./compiler";

import {

DiagnosticCode,

DiagnosticMessage,

DiagnosticEmitter

} from "./diagnostics";

import {

Type,

TypeKind,

TypeFlags,

Signature

} from "./types";

import {

Node,

NodeKind,

Source,

Range,

CommonTypeNode,

TypeParameterNode,

DecoratorNode,

DecoratorKind,

Expression,

IdentifierExpression,

LiteralExpression,

LiteralKind,

StringLiteralExpression,

ClassDeclaration,

DeclarationStatement,

EnumDeclaration,

EnumValueDeclaration,

ExportMember,

ExportStatement,

FieldDeclaration,

FunctionDeclaration,

ImportDeclaration,

ImportStatement,

InterfaceDeclaration,

MethodDeclaration,

NamespaceDeclaration,

TypeDeclaration,

VariableDeclaration,

VariableLikeDeclarationStatement,

VariableStatement,

decoratorNameToKind,

findDecorator,

getSourceLevelNameFromInternalPath,

getSourceLevelName,

} from "./ast";

import {

Module,

NativeType,

FunctionRef,

ExpressionRef,

ExpressionId,

BinaryOp,

UnaryOp,

getExpressionId,

getGetLocalIndex,

isTeeLocal,

getSetLocalValue,

getBinaryOp,

getConstValueI32,

getBinaryLeft,

getBinaryRight,

getUnaryOp,

getExpressionType,

getLoadBytes,

isLoadSigned,

getIfTrue,

getIfFalse,

getSelectThen,

getSelectElse,

getCallTarget,

getBlockChildCount,

getBlockChild,

getBlockName,

getConstValueF32,

getConstValueF64,

getConstValueI64Low

} from "./module";

import {

CharCode,

multiMapAdd

} from "./util";

import {

Resolver

} from "./resolver";

/** Represents a yet unresolved import. */

class QueuedImport {

localName: string;

exportingSource: Source; // Source that should export (or re-export) exportName

// Null for a filespace import. This is the simple name of the export.

exportName: string | null;

// Null for a filespace import.

declaration: ImportDeclaration | null;

}

/**

* Represents a yet unresolved export.

*

* Note that only `export { x };` or `export { x } from "./foo";` may be unresolved;

* a direct export is always resolved immediately.

*

* `export *` is handled by an `exportStars` map, not by a QueuedExport.

*/

class QueuedExport {

/**

* Only set for a local re-export `export { x };`.

* Internal name of the thing being reexported. NOT `member.externalName.text`.

*/

localInternalName: string | null;

/** Only set for a module re-export `export { x } from "./foo";`. */

reExportFromSource: Source | null;

member: ExportMember;

}

/** Represents a type alias. */

class TypeAlias {

typeParameters: TypeParameterNode[] | null;

type: CommonTypeNode;

}

/** Represents a module-level export. */

class ModuleExport {

element: Element;

identifier: IdentifierExpression | null;

}

/** Represents the kind of an operator overload. */

export enum OperatorKind {

INVALID,

// indexed access

INDEXED_GET, // a[]

INDEXED_SET, // a[]=b

UNCHECKED_INDEXED_GET, // unchecked(a[])

UNCHECKED_INDEXED_SET, // unchecked(a[]=b)

// binary

ADD, // a + b

SUB, // a - b

MUL, // a * b

DIV, // a / b

REM, // a % b

POW, // a ** b

BITWISE_AND, // a & b

BITWISE_OR, // a | b

BITWISE_XOR, // a ^ b

BITWISE_SHL, // a << b

BITWISE_SHR, // a >> b

BITWISE_SHR_U, // a >>> b

EQ, // a == b

NE, // a != b

GT, // a > b

GE, // a >= b

LT, // a < b

LE, // a <= b

// unary prefix

PLUS, // +a

MINUS, // -a

NOT, // !a

BITWISE_NOT, // ~a

PREFIX_INC, // ++a

PREFIX_DEC, // --a

// unary postfix

POSTFIX_INC, // a++

POSTFIX_DEC // a--

// not overridable:

// IDENTITY // a === b

// LOGICAL_AND // a && b

// LOGICAL_OR // a || b

}

/** Returns the operator kind represented by the specified decorator and string argument. */

function operatorKindFromDecorator(decoratorKind: DecoratorKind, arg: string): OperatorKind {

assert(arg.length);

switch (decoratorKind) {

case DecoratorKind.OPERATOR:

case DecoratorKind.OPERATOR_BINARY: {

switch (arg.charCodeAt(0)) {

case CharCode.OPENBRACKET: {

if (arg == "[]") return OperatorKind.INDEXED_GET;

if (arg == "[]=") return OperatorKind.INDEXED_SET;

break;

}

case CharCode.OPENBRACE: {

if (arg == "{}") return OperatorKind.UNCHECKED_INDEXED_GET;

if (arg == "{}=") return OperatorKind.UNCHECKED_INDEXED_SET;

break;

}

case CharCode.PLUS: {

if (arg == "+") return OperatorKind.ADD;

break;

}

case CharCode.MINUS: {

if (arg == "-") return OperatorKind.SUB;

break;

}

case CharCode.ASTERISK: {

if (arg == "*") return OperatorKind.MUL;

if (arg == "**") return OperatorKind.POW;

break;

}

case CharCode.SLASH: {

if (arg == "/") return OperatorKind.DIV;

break;

}

case CharCode.PERCENT: {

if (arg == "%") return OperatorKind.REM;

break;

}

case CharCode.AMPERSAND: {

if (arg == "&") return OperatorKind.BITWISE_AND;

break;

}

case CharCode.BAR: {

if (arg == "|") return OperatorKind.BITWISE_OR;

break;

}

case CharCode.CARET: {

if (arg == "^") return OperatorKind.BITWISE_XOR;

break;

}

case CharCode.EQUALS: {

if (arg == "==") return OperatorKind.EQ;

break;

}

case CharCode.EXCLAMATION: {

if (arg == "!=") return OperatorKind.NE;

break;

}

case CharCode.GREATERTHAN: {

if (arg == ">") return OperatorKind.GT;

if (arg == ">=") return OperatorKind.GE;

if (arg == ">>") return OperatorKind.BITWISE_SHR;

if (arg == ">>>") return OperatorKind.BITWISE_SHR_U;

break;

}

case CharCode.LESSTHAN: {

if (arg == "<") return OperatorKind.LT;

if (arg == "<=") return OperatorKind.LE;

if (arg == "<<") return OperatorKind.BITWISE_SHL;

break;

}

}

break;

}

case DecoratorKind.OPERATOR_PREFIX: {

switch (arg.charCodeAt(0)) {

case CharCode.PLUS: {

if (arg == "+") return OperatorKind.PLUS;

if (arg == "++") return OperatorKind.PREFIX_INC;

break;

}

case CharCode.MINUS: {

if (arg == "-") return OperatorKind.MINUS;

if (arg == "--") return OperatorKind.PREFIX_DEC;

break;

}

case CharCode.EXCLAMATION: {

if (arg == "!") return OperatorKind.NOT;

break;

}

case CharCode.TILDE: {

if (arg == "~") return OperatorKind.BITWISE_NOT;

break;

}

}

break;

}

case DecoratorKind.OPERATOR_POSTFIX: {

switch (arg.charCodeAt(0)) {

case CharCode.PLUS: {

if (arg == "++") return OperatorKind.POSTFIX_INC;

break;

}

case CharCode.MINUS: {

if (arg == "--") return OperatorKind.POSTFIX_DEC;

break;

}

}

break;

}

}

return OperatorKind.INVALID;

}

const noTypesYet = new Map<string,Type>();

/** Represents an AssemblyScript program. */

export class Program extends DiagnosticEmitter {

/** Array of source files. */

sources: Source[];

/** Resolver instance. */

resolver: Resolver;

/** Diagnostic offset used where successively obtaining the next diagnostic. */

diagnosticsOffset: i32 = 0;

/** Compiler options. */

options: Options;

/** Elements by internal name. */

elementsLookup: Map<string,Element> = new Map();

/** Class and function instances by internal name. */

instancesLookup: Map<string,Element> = new Map();

/** Types by internal name. */

typesLookup: Map<string,Type> = noTypesYet;

/** Declared type aliases. */

typeAliases: Map<string,TypeAlias> = new Map();

/** File-level exports by exported name. */

fileLevelExports: Map<string,Element> = new Map();

// Maps each re-export from an `export *` (internal path of the re-export location) to the Source that it came from.

// Used to report errors when two `export *`s conflict. (An `export *` does not conflict with an own export.)

exportsFromExportStar = new Set<string>();

/** Module-level exports by exported name. */

moduleLevelExports: Map<string,ModuleExport> = new Map();

/** ArrayBuffer instance reference. */

arrayBufferInstance: Class | null = null;

/** Array prototype reference. */

arrayPrototype: ClassPrototype | null = null;

/** String instance reference. */

stringInstance: Class | null = null;

/** Start function reference. */

startFunction: FunctionPrototype;

/** Main function reference, if present. */

mainFunction: FunctionPrototype | null = null;

/** Abort function reference, if present. */

abortInstance: Function | null = null;

/** Memory allocation function. */

memoryAllocateInstance: Function | null = null;

/** Whether a garbage collector is present or not. */

hasGC: bool = false;

/** Garbage collector allocation function. */

gcAllocateInstance: Function | null = null;

/** Garbage collector link function called when a managed object is referenced from a parent. */

gcLinkInstance: Function | null = null;

/** Garbage collector mark function called to on reachable managed objects. */

gcMarkInstance: Function | null = null;

/** Size of a managed object header. */

gcHeaderSize: u32 = 0;

/** Offset of the GC hook. */

gcHookOffset: u32 = 0;

/** Currently processing filespace. */

currentFilespace: Filespace;

/** Constructs a new program, optionally inheriting parser diagnostics. */

constructor(diagnostics: DiagnosticMessage[] | null = null) {

super(diagnostics);

this.resolver = new Resolver(this);

this.sources = [];

}

/** Gets a source by its exact path. */

getSource(normalizedPath: string): Source | null {

var sources = this.sources;

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

let source = sources[i];

if (source.normalizedPath == normalizedPath) return source;

}

return null;

}

/** Looks up the source for the specified possibly ambiguous path. */

lookupSourceByPath(normalizedPathWithoutExtension: string): Source | null {

var tmp: string;

return (

this.getSource(normalizedPathWithoutExtension + ".ts") ||

this.getSource(normalizedPathWithoutExtension + "/index.ts") ||

this.getSource((tmp = LIBRARY_PREFIX + normalizedPathWithoutExtension) + ".ts") ||

this.getSource( tmp + "/index.ts")

);

}

/** Initializes the program and its elements prior to compilation. */

initialize(options: Options): void {

this.options = options;

// add built-in types

this.typesLookup = new Map([

["i8", Type.i8],

["i16", Type.i16],

["i32", Type.i32],

["i64", Type.i64],

["isize", options.isizeType],

["u8", Type.u8],

["u16", Type.u16],

["u32", Type.u32],

["u64", Type.u64],

["usize", options.usizeType],

["bool", Type.bool],

["f32", Type.f32],

["f64", Type.f64],

["void", Type.void],

["number", Type.f64],

["boolean", Type.bool]

]);

// add compiler hints

this.setConstantInteger("ASC_TARGET", Type.i32,

i64_new(options.isWasm64 ? 2 : 1));

this.setConstantInteger("ASC_NO_TREESHAKING", Type.bool,

i64_new(options.noTreeShaking ? 1 : 0, 0));

this.setConstantInteger("ASC_NO_ASSERT", Type.bool,

i64_new(options.noAssert ? 1 : 0, 0));

this.setConstantInteger("ASC_MEMORY_BASE", Type.i32,

i64_new(options.memoryBase, 0));

this.setConstantInteger("ASC_OPTIMIZE_LEVEL", Type.i32,

i64_new(options.optimizeLevelHint, 0));

this.setConstantInteger("ASC_SHRINK_LEVEL", Type.i32,

i64_new(options.shrinkLevelHint, 0));

this.setConstantInteger("ASC_FEATURE_MUTABLE_GLOBAL", Type.bool,

i64_new(options.hasFeature(Feature.MUTABLE_GLOBAL) ? 1 : 0, 0));

this.setConstantInteger("ASC_FEATURE_SIGN_EXTENSION", Type.bool,

i64_new(options.hasFeature(Feature.SIGN_EXTENSION) ? 1 : 0, 0));

// remember deferred elements

var queuedImports = new Array<QueuedImport>();

var queuedExports = new Map<string,QueuedExport>();

var queuedExtends = new Array<ClassPrototype>();

var queuedImplements = new Array<ClassPrototype>();

// Map from a file to the files it re-exports via `export * from "./foo";`

var exportStars = new Map<Source, Source[]>();

// build initial lookup maps of internal names to declarations

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

let source = this.sources[i];

// create one filespace per source

let filespace = new Filespace(this, source);

this.elementsLookup.set(filespace.internalName, filespace);

this.currentFilespace = filespace;

// process this source's statements

let statements = source.statements;

for (let j = 0, l = statements.length; j < l; ++j) {

let statement = statements[j];

switch (statement.kind) {

case NodeKind.CLASSDECLARATION: {

this.initializeClass(<ClassDeclaration>statement, queuedExtends, queuedImplements);

break;

}

case NodeKind.ENUMDECLARATION: {

this.initializeEnum(<EnumDeclaration>statement);

break;

}

case NodeKind.EXPORT: {

this.initializeExports(source, <ExportStatement>statement, queuedExports, exportStars);

break;

}

case NodeKind.FUNCTIONDECLARATION: {

this.initializeFunction(<FunctionDeclaration>statement);

break;

}

case NodeKind.IMPORT: {

this.initializeImports(<ImportStatement>statement, queuedImports);

break;

}

case NodeKind.INTERFACEDECLARATION: {

this.initializeInterface(<InterfaceDeclaration>statement);

break;

}

case NodeKind.NAMESPACEDECLARATION: {

this.initializeNamespace(<NamespaceDeclaration>statement, queuedExtends, queuedImplements);

break;

}

case NodeKind.TYPEDECLARATION: {

this.initializeTypeAlias(<TypeDeclaration>statement);

break;

}

case NodeKind.VARIABLE: {

this.initializeVariables(<VariableStatement>statement);

break;

}

}

}

}

// queued imports should be resolvable now through traversing exports and queued exports

for (const queuedImport of queuedImports) {

this.resolveAndSetQueuedImport(queuedImport, queuedExports, exportStars);

}

// queued exports should be resolvable now that imports are finalized

for (let [exportInternalName, queuedExport] of queuedExports) {

this.resolveAndSetQueuedExport(exportInternalName, queuedExport, queuedExports, exportStars, new Set<Source>());

}

this.resolveExportStars(exportStars);

// resolve base prototypes of derived classes

var resolver = this.resolver;

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

let derivedPrototype = queuedExtends[i];

let derivedDeclaration = derivedPrototype.declaration;

let derivedType = assert(derivedDeclaration.extendsType);

let baseElement = resolver.resolveIdentifier(derivedType.name, null); // reports

if (!baseElement) continue;

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

let basePrototype = <ClassPrototype>baseElement;

derivedPrototype.basePrototype = basePrototype;

} else {

this.error(

DiagnosticCode.A_class_may_only_extend_another_class,

derivedType.range

);

}

}

// set up global aliases

{

let globalAliases = options.globalAliases;

if (globalAliases) {

for (let [alias, name] of globalAliases) {

if (!name.length) continue; // explicitly disabled

let element = this.elementsLookup.get(name);

if (element) this.elementsLookup.set(alias, element);

else throw new Error("element not found: " + name);

}

}

}

// register 'ArrayBuffer'

if (this.elementsLookup.has("ArrayBuffer")) {

let element = assert(this.elementsLookup.get("ArrayBuffer"));

assert(element.kind == ElementKind.CLASS_PROTOTYPE);

this.arrayBufferInstance = resolver.resolveClass(<ClassPrototype>element, null);

}

// register 'Array'

if (this.elementsLookup.has("Array")) {

let element = assert(this.elementsLookup.get("Array"));

assert(element.kind == ElementKind.CLASS_PROTOTYPE);

this.arrayPrototype = <ClassPrototype>element;

}

// register 'String'

if (this.elementsLookup.has("String")) {

let element = assert(this.elementsLookup.get("String"));

assert(element.kind == ElementKind.CLASS_PROTOTYPE);

let instance = resolver.resolveClass(<ClassPrototype>element, null);

if (instance) {

if (this.typesLookup.has("string")) {

let declaration = (<ClassPrototype>element).declaration;

this.error(

DiagnosticCode.Duplicate_identifier_0,

declaration.name.range, declaration.programLevelInternalName

);

} else {

this.stringInstance = instance;

this.typesLookup.set("string", instance.type);

}

}

}

// register 'start'

{

let element = assert(this.elementsLookup.get("start"));

assert(element.kind == ElementKind.FUNCTION_PROTOTYPE);

this.startFunction = <FunctionPrototype>element;

}

// register 'main' if present

if (this.moduleLevelExports.has("main")) {

let element = (<ModuleExport>this.moduleLevelExports.get("main")).element;

if (

element.kind == ElementKind.FUNCTION_PROTOTYPE &&

!(<FunctionPrototype>element).isAny(CommonFlags.GENERIC | CommonFlags.AMBIENT)

) {

(<FunctionPrototype>element).set(CommonFlags.MAIN);

this.mainFunction = <FunctionPrototype>element;

}

}

// register 'abort' if present

if (this.elementsLookup.has("abort")) {

let element = <Element>this.elementsLookup.get("abort");

assert(element.kind == ElementKind.FUNCTION_PROTOTYPE);

let instance = this.resolver.resolveFunction(<FunctionPrototype>element, null);

if (instance) this.abortInstance = instance;

}

// register 'memory.allocate' if present

if (this.elementsLookup.has("memory")) {

let element = <Element>this.elementsLookup.get("memory");

let members = element.members;

if (members) {

if (members.has("allocate")) {

element = assert(members.get("allocate"));

assert(element.kind == ElementKind.FUNCTION_PROTOTYPE);

let instance = this.resolver.resolveFunction(<FunctionPrototype>element, null);

if (instance) this.memoryAllocateInstance = instance;

}

}

}

// register GC hooks if present

if (

this.elementsLookup.has("__gc_allocate") &&

this.elementsLookup.has("__gc_link") &&

this.elementsLookup.has("__gc_mark")

) {

// __gc_allocate(usize, (ref: usize) => void): usize

let element = <Element>this.elementsLookup.get("__gc_allocate");

assert(element.kind == ElementKind.FUNCTION_PROTOTYPE);

let gcAllocateInstance = assert(this.resolver.resolveFunction(<FunctionPrototype>element, null));

let signature = gcAllocateInstance.signature;

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

assert(signature.parameterTypes[0] == this.options.usizeType);

assert(signature.parameterTypes[1].signatureReference);

assert(signature.returnType == this.options.usizeType);

// __gc_link(usize, usize): void

element = <Element>this.elementsLookup.get("__gc_link");

assert(element.kind == ElementKind.FUNCTION_PROTOTYPE);

let gcLinkInstance = assert(this.resolver.resolveFunction(<FunctionPrototype>element, null));

signature = gcLinkInstance.signature;

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

assert(signature.parameterTypes[0] == this.options.usizeType);

assert(signature.parameterTypes[1] == this.options.usizeType);

assert(signature.returnType == Type.void);

// __gc_mark(usize): void

element = <Element>this.elementsLookup.get("__gc_mark");

assert(element.kind == ElementKind.FUNCTION_PROTOTYPE);

let gcMarkInstance = assert(this.resolver.resolveFunction(<FunctionPrototype>element, null));

signature = gcMarkInstance.signature;

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

assert(signature.parameterTypes[0] == this.options.usizeType);

assert(signature.returnType == Type.void);

this.gcAllocateInstance = gcAllocateInstance;

this.gcLinkInstance = gcLinkInstance;

this.gcMarkInstance = gcMarkInstance;

let gcHookOffset = 2 * options.usizeType.byteSize; // .next + .prev

this.gcHookOffset = gcHookOffset;

this.gcHeaderSize = (gcHookOffset + 4 + 7) & ~7; // + .hook index + alignment

this.hasGC = true;

}

}

private resolveAndSetQueuedImport(

{ declaration, exportingSource, exportName, localName }: QueuedImport,

queuedReExports: Map<string, QueuedExport>,

exportStars: Map<Source, Source[]>

): void {

if (declaration) { // named

let element = this.resolveAndSetExport(

exportingSource, assert(exportName), queuedReExports, exportStars, new Set<Source>());

if (element) {

this.elementsLookup.set(localName, element);

} else {

this.error(

DiagnosticCode.Module_0_has_no_exported_member_1,

declaration.range,

(<ImportStatement>declaration.parent).path.value,

declaration.externalName.text

);

}

} else { // filespace

// Filespace lookup must succeed, because would have failed already in the parser if the file didn't exist.

this.elementsLookup.set(localName, this.elementsLookup.get(FILESPACE_PREFIX + exportingSource.internalPath)!);

}

}

private resolveExportStars(exportStars: Map<Source, Source[]>): void {

// Source -> list of Sources we need to copy its exports to.

var reverse = new Map<Source, Source[]>();

for (const [to, froms] of exportStars) {

for (const from of froms) {

multiMapAdd(reverse, from, to);

}

}

// For each original export, find all sources it needs to be (transitively) re-exported to.

for (const [originalSource, directReExportDestinations] of reverse) {

const originalFilespace = this.getFilespace(originalSource);

const destinations = directReExportDestinations.slice();

const seenDestinations = new Set<Source>();

seenDestinations.add(originalSource); // If A reexports all from B and vice-versa, don't want to loop back to A.

while (destinations.length) {

const destination = destinations.pop()!;

if (seenDestinations.has(destination)) continue;

seenDestinations.add(destination);

for (const transitiveDestination of reverse.get(destination) || []) {

destinations.push(transitiveDestination);

}

for (const [simpleName, element] of originalFilespace.members) {

const internalName = getSourceLevelName(destination, simpleName);

if (this.fileLevelExports.has(internalName)) {

// An own export overrides an `export *` re-export. Only another `export *` re-export is a problem.

if (this.exportsFromExportStar.has(internalName)) {

this.error(

DiagnosticCode.Module_0_has_already_exported_a_member_named_1_Consider_explicitly_re_exporting_to_resolve_the_ambiguity,

destination.range,

destination.normalizedPath,

simpleName,

);

}

} else {

this.setExportFromExportStar(element, destination, simpleName);

}

}

}

}

}

private resolveAndSetQueuedExport(

// `exportInternalName` is the internal name of the alias, and `externalName` is the internal name of the original.

exportInternalName: string,

{ localInternalName, reExportFromSource, member }: QueuedExport,

queuedExports: Map<string, QueuedExport>,

exportStars: Map<Source, Source[]>,

seenSources: Set<Source>,

): Element | null {

const originalSimpleName = member.name.text;

const element = reExportFromSource

// `export { x } from "./foo";`

? this.resolveAndSetExport(

reExportFromSource, originalSimpleName, queuedExports, exportStars, seenSources)

// `export { x };`: normal export || library re-export

: this.elementsLookup.get(localInternalName!) || this.elementsLookup.get(originalSimpleName);

if (element) {

// `resolveAndSetExport` sets the export on the original; this sets the export on the alias.

this.setExportAndCheckLibrary(

exportInternalName, element, member.range.source, member.externalName.text, member.range);

}

else {

this.error(

DiagnosticCode.Module_0_has_no_exported_member_1,

member.externalName.range,

(<ExportStatement>member.parent).path!.value,

originalSimpleName,

);

}

return element;

}

/**

* Does not report errors. Caller should report an error on null if needed.

* (If a file has two `export *`s, only one of them should have the export, so the other is not an error.)

*/

private resolveAndSetExport(

exportingSource: Source,

exportSimpleName: string,

queuedExports: Map<string, QueuedExport>,

exportStars: Map<Source, Source[]>,

seenSources: Set<Source>,

): Element | null {

const exportInternalPath = getSourceLevelName(exportingSource, exportSimpleName);

const cached = this.fileLevelExports.get(exportInternalPath);

if (cached) return cached;

const queuedExport = queuedExports.get(exportInternalPath);

if (queuedExport) {

// This redirects to another queued export, so resolve that.

return this.resolveAndSetQueuedExport(exportSimpleName, queuedExport, queuedExports, exportStars, seenSources);

}

return this.resolveAndSetReExportFromExportStar(

exportingSource, exportSimpleName, queuedExports, exportStars, seenSources);

}

private resolveAndSetReExportFromExportStar(

exportingSource: Source,

exportSimpleName: string,

queuedExports: Map<string, QueuedExport>,

exportStars: Map<Source, Source[]>,

seenSources: Set<Source>,

): Element | null {

// Avoid infinite loops -- don't look in the same source more than once.

if (seenSources.has(exportingSource)) {

return null;

}

seenSources.add(exportingSource);

for (const reExportedSource of exportStars.get(exportingSource) || []) {

const element = this.resolveAndSetExport(

reExportedSource,

exportSimpleName,

queuedExports,

exportStars,

seenSources

);

if (element) {

this.setExportFromExportStar(element, exportingSource, exportSimpleName);

return element;

// If there are two reexports with the same name, we will error in `resolveExportStars`.

}

}

return null;

}

/** Sets a constant integer value. */

setConstantInteger(globalName: string, type: Type, value: I64): void {

assert(type.is(TypeFlags.INTEGER));

this.elementsLookup.set(globalName,

new Global(this, globalName, globalName, type, null, DecoratorFlags.NONE)

.withConstantIntegerValue(value)

);

}

/** Sets a constant float value. */

setConstantFloat(globalName: string, type: Type, value: f64): void {

assert(type.is(TypeFlags.FLOAT));

this.elementsLookup.set(globalName,

new Global(this, globalName, globalName, type, null, DecoratorFlags.NONE)

.withConstantFloatValue(value)

);

}

/** Checks that only supported decorators are present. */

private checkDecorators(

decorators: DecoratorNode[],

acceptedFlags: DecoratorFlags

): DecoratorFlags {

var presentFlags = DecoratorFlags.NONE;

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

let decorator = decorators[i];

let kind = decoratorNameToKind(decorator.name);

let flag = decoratorKindToFlag(kind);

if (flag) {

if (flag == DecoratorFlags.BUILTIN) {

if (decorator.range.source.isLibrary) {

presentFlags |= flag;

} else {

this.error(

DiagnosticCode.Decorator_0_is_not_valid_here,

decorator.range, decorator.name.range.toString()

);

}

} else if (!(acceptedFlags & flag)) {

this.error(

DiagnosticCode.Decorator_0_is_not_valid_here,

decorator.range, decorator.name.range.toString()

);

} else if (presentFlags & flag) {

this.error(

DiagnosticCode.Duplicate_decorator,

decorator.range, decorator.name.range.toString()

);

} else {

presentFlags |= flag;

}

}

}

return presentFlags;

}

/** Checks and sets up global options of an element. */

private checkGlobal(

element: Element,

declaration: DeclarationStatement

): void {

var parentNode = declaration.parent;

// alias globally if explicitly annotated @global or exported from a top-level library file

if (

(element.hasDecorator(DecoratorFlags.GLOBAL)) ||

(

declaration.range.source.isLibrary &&

element.is(CommonFlags.EXPORT) &&

(

assert(parentNode).kind == NodeKind.SOURCE ||

(

<Node>parentNode).kind == NodeKind.VARIABLE &&

assert((<Node>parentNode).parent).kind == NodeKind.SOURCE

)

)

) {

let globalName = declaration.programLevelInternalName;

if (this.elementsLookup.has(globalName)) {

this.error(

DiagnosticCode.Duplicate_identifier_0,

declaration.name.range, element.internalName

);

} else {

this.elementsLookup.set(globalName, element);

}

}

// builtins use the global name directly

if (element.hasDecorator(DecoratorFlags.BUILTIN)) {

element.internalName = declaration.programLevelInternalName;

}

}

/** Initializes a class declaration. */

private initializeClass(

declaration: ClassDeclaration,

queuedExtends: ClassPrototype[],

queuedImplements: ClassPrototype[],

namespace: Element | null = null

): void {

var internalName = declaration.fileLevelInternalName;

if (this.elementsLookup.has(internalName)) {

this.error(

DiagnosticCode.Duplicate_identifier_0,

declaration.name.range, internalName

);

return;

}

var decorators = declaration.decorators;

var simpleName = declaration.name.text;

var prototype = new ClassPrototype(

this,

simpleName,

internalName,

declaration,

decorators

? this.checkDecorators(decorators,

DecoratorFlags.GLOBAL |

DecoratorFlags.SEALED |

DecoratorFlags.UNMANAGED

)

: DecoratorFlags.NONE

);

prototype.parent = namespace;

this.elementsLookup.set(internalName, prototype);

var implementsTypes = declaration.implementsTypes;

if (implementsTypes) {

let numImplementsTypes = implementsTypes.length;

if (prototype.hasDecorator(DecoratorFlags.UNMANAGED)) {

if (numImplementsTypes) {

this.error(

DiagnosticCode.Unmanaged_classes_cannot_implement_interfaces,

Range.join(

declaration.name.range,

implementsTypes[numImplementsTypes - 1].range

)

);

}

// remember classes that implement interfaces

} else if (numImplementsTypes) {

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

this.warning( // TODO

DiagnosticCode.Operation_not_supported,

implementsTypes[i].range

);

}

queuedImplements.push(prototype);

}

}

// remember classes that extend another one

if (declaration.extendsType) queuedExtends.push(prototype);

// add as namespace member if applicable

if (namespace) {

if (namespace.members) {

if (namespace.members.has(simpleName)) {

this.error(

DiagnosticCode.Duplicate_identifier_0,

declaration.name.range, internalName

);

return;

}

} else {

namespace.members = new Map();

}

namespace.members.set(simpleName, prototype);

if (namespace.is(CommonFlags.MODULE_EXPORT) && prototype.is(CommonFlags.EXPORT)) {

prototype.set(CommonFlags.MODULE_EXPORT);