Properly inline getters; Simplify blocks when last statement returns

Author: dcodeIO

dist/asc.js

@@ -1413,6 +1413,20 @@ export class UnaryPrefixExpression extends UnaryExpression {
 
 // statements
 
+export function isLastStatement(statement: Statement): bool {
+  var parent = assert(statement.parent);
+  if (parent.kind == NodeKind.BLOCK) {
+    let statements = (<BlockStatement>parent).statements;
+    if (statements[statements.length - 1] === statement) {
+      switch (assert(parent.parent).kind) {
+        case NodeKind.FUNCTIONDECLARATION:
+        case NodeKind.METHODDECLARATION: return true;
+      }
+    }
+  }
+  return false;
+}
+
 /** Base class of all statement nodes. */
 export abstract class Statement extends Node { }
 

dist/asc.js.map

@@ -128,7 +128,8 @@ import {
   UnaryPrefixExpression,
   FieldDeclaration,
 
-  nodeIsConstantValue
+  nodeIsConstantValue,
+  isLastStatement
 } from "./ast";
 
 import {
@@ -1486,11 +1487,17 @@ export class Compiler extends DiagnosticEmitter {
     this.currentFunction.flow = blockFlow;
 
     var stmts = this.compileStatements(statements);
+    var lastType: NativeType;
     var stmt = stmts.length == 0
       ? this.module.createNop()
       : stmts.length == 1
         ? stmts[0]
-        : this.module.createBlock(null, stmts, NativeType.None);
+        : this.module.createBlock(null, stmts,
+            // if the last expression is a value, annotate the block's return value
+            (lastType = getExpressionType(stmts[stmts.length - 1])) == NativeType.None
+              ? NativeType.None
+              : lastType
+          );
 
     // Switch back to the parent flow
     var parentFlow = blockFlow.leaveBranchOrScope();
@@ -1776,6 +1783,9 @@ export class Compiler extends DiagnosticEmitter {
       if (!flow.canOverflow(expr, returnType)) flow.set(FlowFlags.RETURNS_WRAPPED);
     }
 
+    // If the last statement anyway, make it the block's return value
+    if (isLastStatement(statement)) return expr ? expr : module.createNop();
+
     // When inlining, break to the end of the inlined function's block (no need to wrap)
     return flow.is(FlowFlags.INLINE_CONTEXT)
       ? module.createBreak(assert(flow.returnLabel), 0, expr)
@@ -6440,6 +6450,7 @@ export class Compiler extends DiagnosticEmitter {
           )) {
             return module.createUnreachable();
           }
+          let inline = (instance.decoratorFlags & DecoratorFlags.INLINE) != 0;
           if (instance.is(CommonFlags.INSTANCE)) {
             let parent = assert(instance.parent);
             assert(parent.kind == ElementKind.CLASS);
@@ -6450,10 +6461,10 @@ export class Compiler extends DiagnosticEmitter {
               WrapMode.NONE
             );
             this.currentType = signature.returnType;
-            return this.compileCallDirect(instance, [], propertyAccess, thisExpr);
+            return this.compileCallDirect(instance, [], propertyAccess, thisExpr, inline);
           } else {
             this.currentType = signature.returnType;
-            return this.compileCallDirect(instance, [], propertyAccess);
+            return this.compileCallDirect(instance, [], propertyAccess, 0, inline);
           }
         } else {
           this.error(

dist/assemblyscript.js

@@ -3,6 +3,8 @@
  * @module std/assembly
  *//***/
 
+/// <reference no-default-lib="true"/>
+
 // Types
 
 /** An 8-bit signed integer. */
@@ -467,11 +469,12 @@ declare class Set<T> {
   clear(): void;
 }
 
-declare class Symbol {
-  constructor(description?: string | null);
-  static for(key: string): Symbol;
-  static keyFor(sym: Symbol): string | null;
+interface SymbolConstructor {
+  (description?: string | null): symbol;
+  for(key: string): symbol;
+  keyFor(sym: symbol): string | null;
 }
+declare const Symbol: SymbolConstructor;
 
 interface IMath<T> {
   /** The base of natural logarithms, e, approximately 2.718. */

dist/assemblyscript.js.map

@@ -1,30 +1,50 @@
 import { Map } from "./map";
 
-var nextId: usize = 1;
 var stringToId: Map<string, usize>;
 var idToString: Map<usize, string>;
+var nextId: usize = 12; // Symbol.unscopables + 1
 
-export class Symbol {
+@unmanaged export class symbol {}
 
-  static for(key: string): Symbol {
+type Symbol = symbol;
+
+export function Symbol(description: string | null = null): symbol {
+  var id = nextId++;
+  if (!id) unreachable(); // out of ids
+  return changetype<symbol>(id);
+}
+
+export namespace Symbol {
+
+  // well-known symbols
+  export const hasInstance      = changetype<symbol>(1);
+  export const concatSpreadable = changetype<symbol>(2);
+  export const isRegExp         = changetype<symbol>(3);
+  export const iterator         = changetype<symbol>(3);
+  export const match            = changetype<symbol>(4);
+  export const replace          = changetype<symbol>(5);
+  export const search           = changetype<symbol>(6);
+  export const species          = changetype<symbol>(7);
+  export const split            = changetype<symbol>(8);
+  export const toPrimitive      = changetype<symbol>(9);
+  export const toStringTag      = changetype<symbol>(10);
+  export const unscopables      = changetype<symbol>(11);
+
+  /* tslint:disable */// not valid TS
+  export function for(key: string): symbol {
     if (!stringToId) { stringToId = new Map(); idToString = new Map(); }
-    else if (stringToId.has(key)) return changetype<Symbol>(stringToId.get(key));
+    else if (stringToId.has(key)) return changetype<symbol>(stringToId.get(key));
     var id = nextId++;
     if (!id) unreachable(); // out of ids
     stringToId.set(key, id);
     idToString.set(id, key);
-    return changetype<Symbol>(id);
+    return changetype<symbol>(id);
   }
+  /* tslint:enable */
 
-  static keyFor(sym: Symbol): string | null {
+  export function keyFor(sym: symbol): string | null {
     return idToString !== null && idToString.has(changetype<usize>(sym))
       ? idToString.get(changetype<usize>(sym))
       : null;
   }
-
-  constructor(description: string | null = null) {
-    var id = nextId++;
-    if (!id) unreachable(); // out of ids
-    return changetype<Symbol>(id);
-  }
 }

src/ast.ts

@@ -12,6 +12,8 @@
  * @module std/portable
  *//***/
 
+/// <reference no-default-lib="true"/>
+
 // Portable types
 
 declare type i8 = number;
@@ -309,11 +311,6 @@ declare class Error {
   stack: string | null;
 }
 
-declare class Symbol {
-  private constructor();
-  static readonly iterator: symbol;
-}
-
 declare class Set<T> {
   constructor(entries?: T[]);
   readonly size: i32;
@@ -337,6 +334,14 @@ declare class Map<K,V> {
   [Symbol.iterator](): Iterator<[K,V]>;
 }
 
+interface SymbolConstructor {
+  (description?: string | null): symbol;
+  for(key: string): symbol;
+  keyFor(sym: symbol): string | null;
+  readonly iterator: symbol;
+}
+declare const Symbol: SymbolConstructor;
+
 interface Iterable<T> {
   [Symbol.iterator](): Iterator<T>;
 }

src/compiler.ts

@@ -14,35 +14,27 @@
  (export "memory" (memory $0))
  (start $start)
  (func $abi/exported (; 1 ;) (type $i) (result i32)
-  (return
-   (i32.shr_s
-    (i32.shl
-     (i32.const 128)
-     (i32.const 24)
-    )
+  (i32.shr_s
+   (i32.shl
+    (i32.const 128)
     (i32.const 24)
    )
+   (i32.const 24)
   )
  )
  (func $abi/exportedExported (; 2 ;) (type $i) (result i32)
-  (return
-   (call $abi/exported)
-  )
+  (call $abi/exported)
  )
  (func $abi/internal (; 3 ;) (type $i) (result i32)
-  (return
-   (i32.const 128)
-  )
+  (i32.const 128)
  )
  (func $abi/exportedInternal (; 4 ;) (type $i) (result i32)
-  (return
-   (i32.shr_s
-    (i32.shl
-     (call $abi/internal)
-     (i32.const 24)
-    )
+  (i32.shr_s
+   (i32.shl
+    (call $abi/internal)
     (i32.const 24)
    )
+   (i32.const 24)
   )
  )
  (func $start (; 5 ;) (type $v)