Namespaces

Author: dcodeIO

README.md

@@ -5,7 +5,7 @@ AssemblyScript NEXT
 
 **AssemblyScript** is a new compiler targeting [WebAssembly](http://webassembly.org) while utilizing [TypeScript](http://www.typescriptlang.org)'s syntax and [node](https://nodejs.org)'s vibrant ecosystem. Instead of requiring complex toolchains to set up, you can simply `npm install` it - or run it in a browser.
 
-By compiling syntactially but not necessarily semantically valid TypeScript to [Binaryen](https://github.com/WebAssembly/binaryen) IR, the resulting module can be validated, optimized, emitted in WebAssembly text or binary format and converted to [asm.js](http://asmjs.org) as a polyfill.
+By compiling syntactially (not necessarily semantically) valid TypeScript to [Binaryen](https://github.com/WebAssembly/binaryen) IR, the resulting module can be validated, optimized, emitted in WebAssembly text or binary format and converted to [asm.js](http://asmjs.org) as a polyfill.
 
 The compiler itself utilizes "portable definitions" so it can be compiled to both JavaScript using `tsc` and, eventually, to WebAssembly using `asc`.
 

bin/asc.js

@@ -130,7 +130,8 @@ args._.forEach(filename => {
 var options = assemblyscript.createOptions();
 assemblyscript.setTarget(options, 0);
 assemblyscript.setNoTreeShaking(options, args.noTreeShaking);
-assemblyscript.setNoDebug(options, args.noDebug);
+assemblyscript.setNoAssert(options, args.noAssert);
+// TODO: noDebug binaryen feature, removing names the debug section
 
 var module = assemblyscript.compile(parser, options);
 checkDiagnostics(parser);

bin/asc.json

@@ -43,7 +43,7 @@
     "desc": "Disables tree-shaking.",
     "type": "boolean"
   },
-  "noDebug": {
+  "noAssert": {
     "desc": "Disables assertions.",
     "type": "boolean"
   },

src/ast.ts

@@ -1809,12 +1809,16 @@ export function mangleInternalName(declaration: DeclarationStatement): string {
       }
     }
   }
-  if (!declaration.parent)
+  let parent: Node | null = declaration.parent;
+  if (!parent)
     return name;
-  if (declaration.parent.kind == NodeKind.CLASS)
-    return (<ClassDeclaration>declaration.parent).internalName + (hasModifier(ModifierKind.STATIC, declaration.modifiers) ? STATIC_DELIMITER : INSTANCE_DELIMITER) + name;
-  if (declaration.parent.kind == NodeKind.NAMESPACE || declaration.parent.kind == NodeKind.ENUM)
-    return (<DeclarationStatement>declaration.parent).internalName + STATIC_DELIMITER + name;
+  if (declaration.kind == NodeKind.VARIABLEDECLARATION && parent.kind == NodeKind.VARIABLE) // skip over
+    if (!(parent = parent.parent))
+      return name;
+  if (parent.kind == NodeKind.CLASS)
+    return (<ClassDeclaration>parent).internalName + (hasModifier(ModifierKind.STATIC, declaration.modifiers) ? STATIC_DELIMITER : INSTANCE_DELIMITER) + name;
+  if (parent.kind == NodeKind.NAMESPACE || parent.kind == NodeKind.ENUM)
+    return (<DeclarationStatement>parent).internalName + STATIC_DELIMITER + name;
   return declaration.range.source.internalPath + PATH_DELIMITER + name;
 }
 

src/builtins.ts

@@ -494,7 +494,7 @@ export function compileCall(compiler: Compiler, prototype: FunctionPrototype, ty
         return module.createUnreachable();
       arg0 = compiler.compileExpression(operands[0], Type.i32); // reports
       compiler.currentType = Type.void;
-      return compiler.options.noDebug
+      return compiler.options.noAssert
         ? module.createNop()
         : module.createIf(
             module.createUnary(UnaryOp.EqzI32, arg0),

src/compiler.ts

@@ -119,7 +119,7 @@ export class Options {
   /** If true, compiles everything instead of just reachable code. */
   noTreeShaking: bool = false;
   /** If true, replaces assertions with nops. */
-  noDebug: bool = false;
+  noAssert: bool = false;
 }
 
 const enum ConversionKind {
@@ -306,7 +306,7 @@ export class Compiler extends DiagnosticEmitter {
       throw new Error("unexpected missing global");
     if (!this.compileGlobal(<Global>element))
       return null;
-    if (declaration.range.source.isEntry && (<VariableStatement>declaration.parent).parent == declaration.range.source && hasModifier(ModifierKind.EXPORT, declaration.modifiers)) {
+    if (isModuleExport(element, declaration)) {
       if ((<Global>element).hasConstantValue)
         this.module.addGlobalExport(element.internalName, declaration.identifier.name);
       else
@@ -470,7 +470,7 @@ export class Compiler extends DiagnosticEmitter {
     const instance: Function | null = this.compileFunctionUsingTypeArguments(<FunctionPrototype>element, typeArguments, contextualTypeArguments, alternativeReportNode);
     if (!instance)
       return;
-    if (declaration.range.source.isEntry && declaration.parent == declaration.range.source && hasModifier(ModifierKind.EXPORT, declaration.modifiers))
+    if (isModuleExport(instance, declaration))
       this.module.addFunctionExport(instance.internalName, declaration.identifier.name);
   }
 
@@ -527,7 +527,7 @@ export class Compiler extends DiagnosticEmitter {
 
     // create the function
     const internalName: string = instance.internalName;
-    if (instance.isDeclared) {
+    if (instance.isDeclared) { // TODO: use parent namespace as externalModuleName, if applicable
       this.module.addFunctionImport(internalName, "env", declaration.identifier.name, typeRef);
     } else {
       this.module.addFunction(internalName, typeRef, typesToNativeTypes(instance.additionalLocals), this.module.createBlock(null, <ExpressionRef[]>stmts, NativeType.None));
@@ -573,7 +573,6 @@ export class Compiler extends DiagnosticEmitter {
           throw new Error("unexpected namespace member");
       }
     }
-    throw new Error("not implemented");
   }
 
   compileNamespace(ns: Namespace): void {
@@ -1834,7 +1833,115 @@ export class Compiler extends DiagnosticEmitter {
     return this.compileExpression(expression.expression, contextualType, ConversionKind.NONE);
   }
 
-  compilePropertyAccessExpression(expression: PropertyAccessExpression, contextualType: Type): ExpressionRef {
+  compilePropertyAccessExpression(propertyAccess: PropertyAccessExpression, contextualType: Type): ExpressionRef {
+    const expression: Expression = propertyAccess.expression;
+    const propertyName: string = propertyAccess.property.name;
+
+    // the lhs expression is either 'this', 'super', an identifier or another property access
+    let target: Element | null;
+    switch (expression.kind) {
+
+      default:
+        throw new Error("unexpected expression kind");
+
+      case NodeKind.THIS:
+        if (!this.currentFunction.instanceMethodOf) {
+          this.error(DiagnosticCode._this_cannot_be_referenced_in_current_location, expression.range);
+          return this.module.createUnreachable();
+        }
+        target = this.currentFunction.instanceMethodOf;
+        break;
+
+      case NodeKind.SUPER:
+        if (!(this.currentFunction.instanceMethodOf && this.currentFunction.instanceMethodOf.base)) {
+          this.error(DiagnosticCode._super_can_only_be_referenced_in_a_derived_class, expression.range);
+          return this.module.createUnreachable();
+        }
+        target = this.currentFunction.instanceMethodOf.base;
+        break;
+
+      case NodeKind.IDENTIFIER:
+        target = this.program.resolveIdentifier(<IdentifierExpression>expression, this.currentFunction); // reports
+        break;
+
+      case NodeKind.PROPERTYACCESS:
+        target = this.program.resolvePropertyAccess(<PropertyAccessExpression>expression, this.currentFunction); // reports
+        break;
+    }
+    if (!target)
+      return this.module.createUnreachable();
+
+    // look up the property within the target to obtain the actual element
+    let element: Element | null;
+    let expr: ExpressionRef;
+    switch (target.kind) {
+
+      // handle enum value right away
+
+      case ElementKind.ENUM:
+        element = (<Enum>target).members.get(propertyName);
+        if (!element) {
+          this.error(DiagnosticCode.Property_0_does_not_exist_on_type_1, propertyAccess.property.range, propertyName);
+          return this.module.createUnreachable();
+        }
+        this.currentType = Type.i32;
+        return (<EnumValue>element).hasConstantValue
+          ? this.module.createI32((<EnumValue>element).constantValue)
+          : this.module.createGetGlobal((<EnumValue>element).internalName, NativeType.I32);
+
+      // postpone everything else
+
+      case ElementKind.LOCAL:
+        element = (<Local>target).type.classType;
+        if (!element) {
+          this.error(DiagnosticCode.Property_0_does_not_exist_on_type_1, propertyAccess.property.range, propertyName, (<Local>target).type.toString());
+          return this.module.createUnreachable();
+        }
+        target = element;
+        break;
+
+      case ElementKind.GLOBAL:
+        if (!this.compileGlobal(<Global>target))
+          return this.module.createUnreachable();
+        element = (<Type>(<Global>target).type).classType;
+        if (!element) {
+          this.error(DiagnosticCode.Property_0_does_not_exist_on_type_1, propertyAccess.property.range, propertyName, (<Local>target).type.toString());
+          return this.module.createUnreachable();
+        }
+        target = element;
+        break;
+
+      case ElementKind.NAMESPACE:
+        element =  (<Namespace>target).members.get(propertyName);
+        if (!(element && element.isExported)) {
+          this.error(DiagnosticCode.Namespace_0_has_no_exported_member_1, propertyAccess.property.range, (<Namespace>target).internalName, propertyName);
+          return this.module.createUnreachable();
+        }
+        target = element;
+        break;
+
+      default:
+        throw new Error("unexpected target kind");
+    }
+
+    // handle the element
+    switch (element.kind) {
+
+      case ElementKind.LOCAL:
+        return this.module.createGetLocal((<Local>element).index, typeToNativeType(this.currentType = (<Local>element).type));
+
+      case ElementKind.GLOBAL:
+        this.compileGlobal(<Global>element);
+        return this.module.createGetGlobal((<Global>element).internalName, typeToNativeType(this.currentType = <Type>(<Global>element).type));
+
+      case ElementKind.FUNCTION: // getter
+        if (!(<Function>element).prototype.isGetter) {
+          this.error(DiagnosticCode.Property_0_does_not_exist_on_type_1, propertyAccess.property.range, propertyName, element.internalName);
+          return this.module.createUnreachable();
+        }
+        return this.compileCall(<Function>element, [], propertyAccess);
+    }
+    this.error(DiagnosticCode.Operation_not_supported, propertyAccess.range);
     throw new Error("not implemented");
   }
 
@@ -2031,3 +2138,22 @@ function typesToSignatureName(paramTypes: Type[], returnType: Type): string {
   sb.push(typeToSignatureNamePart(returnType));
   return sb.join("");
 }
+
+function isModuleExport(element: Element, declaration: DeclarationStatement): bool {
+  if (!element.isExported)
+    return false;
+  if (declaration.range.source.isEntry)
+    return true;
+  let parentNode: Node | null = declaration.parent;
+  if (!parentNode)
+    return false;
+  if (parentNode.kind == NodeKind.VARIABLE)
+    if (!(parentNode = parentNode.parent))
+      return false;
+  if (parentNode.kind != NodeKind.NAMESPACE && parentNode.kind != NodeKind.CLASS)
+    return false;
+  let parent: Element | null = element.program.elements.get((<DeclarationStatement>parentNode).internalName);
+  if (!parent)
+    return false;
+  return isModuleExport(parent, <DeclarationStatement>parentNode);
+}

src/diagnosticMessages.generated.ts

@@ -57,6 +57,7 @@ export enum DiagnosticCode {
   Type_0_is_not_generic = 2315,
   Type_0_is_not_assignable_to_type_1 = 2322,
   _this_cannot_be_referenced_in_current_location = 2332,
+  _super_can_only_be_referenced_in_a_derived_class = 2335,
   Property_0_does_not_exist_on_type_1 = 2339,
   Cannot_invoke_an_expression_whose_type_lacks_a_call_signature_Type_0_has_no_compatible_call_signatures = 2349,
   The_operand_of_an_increment_or_decrement_operator_must_be_a_variable_or_a_property_access = 2357,
@@ -69,6 +70,7 @@ export enum DiagnosticCode {
   Expected_0_arguments_but_got_1 = 2554,
   Expected_at_least_0_arguments_but_got_1 = 2555,
   Expected_0_type_arguments_but_got_1 = 2558,
+  Namespace_0_has_no_exported_member_1 = 2694,
   File_0_not_found = 6054
 }
 
@@ -130,6 +132,7 @@ export function diagnosticCodeToString(code: DiagnosticCode): string {
     case 2315: return "Type '{0}' is not generic.";
     case 2322: return "Type '{0}' is not assignable to type '{1}'.";
     case 2332: return "'this' cannot be referenced in current location.";
+    case 2335: return "'super' can only be referenced in a derived class.";
     case 2339: return "Property '{0}' does not exist on type '{1}'.";
     case 2349: return "Cannot invoke an expression whose type lacks a call signature. Type '{0}' has no compatible call signatures.";
     case 2357: return "The operand of an increment or decrement operator must be a variable or a property access.";
@@ -142,6 +145,7 @@ export function diagnosticCodeToString(code: DiagnosticCode): string {
     case 2554: return "Expected {0} arguments, but got {1}.";
     case 2555: return "Expected at least {0} arguments, but got {1}.";
     case 2558: return "Expected {0} type arguments, but got {1}.";
+    case 2694: return "Namespace '{0}' has no exported member '{1}'.";
     case 6054: return "File '{0}' not found.";
     default: return "";
   }

src/diagnosticMessages.json

@@ -57,6 +57,7 @@
   "Type '{0}' is not generic.": 2315,
   "Type '{0}' is not assignable to type '{1}'.": 2322,
   "'this' cannot be referenced in current location.": 2332,
+  "'super' can only be referenced in a derived class.": 2335,
   "Property '{0}' does not exist on type '{1}'.": 2339,
   "Cannot invoke an expression whose type lacks a call signature. Type '{0}' has no compatible call signatures.": 2349,
   "The operand of an increment or decrement operator must be a variable or a property access.": 2357,
@@ -69,6 +70,7 @@
   "Expected {0} arguments, but got {1}.": 2554,
   "Expected at least {0} arguments, but got {1}.": 2555,
   "Expected {0} type arguments, but got {1}.": 2558,
+  "Namespace '{0}' has no exported member '{1}'.": 2694,
 
   "File '{0}' not found.": 6054
 }

src/diagnostics.ts

@@ -155,7 +155,7 @@ export abstract class DiagnosticEmitter {
     const message: DiagnosticMessage = DiagnosticMessage.create(code, category, arg0, arg1).withRange(range);
     this.diagnostics.push(message);
     console.log(formatDiagnosticMessage(message, true, true) + "\n"); // temporary
-    // console.log(new Error().stack);
+    console.log(<string>new Error("stack").stack);
   }
 
   error(code: DiagnosticCode, range: Range, arg0: string | null = null, arg1: string | null = null): void {

src/index.ts

@@ -84,9 +84,9 @@ export function setNoTreeShaking(options: Options, noTreeShaking: bool): void {
   options.noTreeShaking = noTreeShaking;
 }
 
-/** Sets the `noDebug` option. */
-export function setNoDebug(options: Options, noDebug: bool): void {
-  options.noDebug = noDebug;
+/** Sets the `noAssert` option. */
+export function setNoAssert(options: Options, noAssert: bool): void {
+  options.noAssert = noAssert;
 }
 
 /** Compiles the sources computed by the parser to a module. */