Upgrade glimmer-vm to latest

broccoli/packages.js

@@ -86,7 +86,41 @@ module.exports.emberGlimmerES = function _emberGlimmerES() {
     }
   });
 
-  return debugTree(funneled, 'ember-glimmer:output');
+  let rollup = new Rollup(funneled, {
+    annotation: 'ember-glimmer',
+    rollup: {
+      external: [
+        '@glimmer/reference',
+        '@glimmer/runtime',
+        '@glimmer/node',
+        '@glimmer/opcode-compiler',
+        '@glimmer/program',
+        '@glimmer/wire-format',
+        '@glimmer/util',
+        'ember-console',
+        'ember-debug',
+        'ember-env-flags',
+        'ember/features',
+        'ember-environment',
+        'ember-utils',
+        'ember-metal',
+        'ember-runtime',
+        'ember-views',
+        'ember-routing',
+        'node-module',
+        'rsvp',
+        'container'
+      ],
+      input: 'ember-glimmer/index.js',
+      output: {
+        file: 'ember-glimmer.js',
+        format: 'es',
+        exports: 'named'
+      },
+    },
+  });
+
+  return debugTree(rollup, 'ember-glimmer:output');
 };
 
 module.exports.handlebarsES = function _handlebars() {

broccoli/to-es5.js

@@ -36,6 +36,7 @@ module.exports = function toES5(tree, _options) {
       }
     }],
     ['transform-es2015-template-literals', {loose: true}],
+    ['transform-es2015-literals'],
     ['transform-es2015-arrow-functions'],
     ['transform-es2015-destructuring', {loose: true}],
     ['transform-es2015-spread', {loose: true}],

ember-cli-build.js

@@ -35,12 +35,12 @@ const {
   rollupEmberMetal
 } = require('./broccoli/packages');
 const SHOULD_ROLLUP = true;
+const ENV = process.env.EMBER_ENV || 'development';
 
 module.exports = function() {
   let loader = internalLoader();
   let license = emberLicense();
   let nodeModule = nodeModuleUtils();
-  let ENV = process.env.EMBER_ENV || 'development';
   let debugFeatures = toES5(emberFeaturesES());
   let version = toES5(emberVersionES());
   let emberTesting = emberPkgES('ember-testing');
@@ -49,7 +49,6 @@ module.exports = function() {
   let emberDebugES5 = toES5(emberDebug, { annotation: 'ember-debug' });
   let emberTemplateCompiler = emberPkgES('ember-template-compiler');
   let emberTemplateCompilerES5 = toES5(emberTemplateCompiler, { annotation: 'ember-template-compiler' });
-
   let babelDebugHelpersES5 = toES5(babelHelpers('debug'), { annotation: 'babel helpers debug' });
   let inlineParser = toES5(handlebarsES(), { annotation: 'handlebars' });
   let tokenizer = toES5(simpleHTMLTokenizerES(), { annotation: 'tokenizer' });
@@ -309,11 +308,23 @@ module.exports = function() {
 };
 
 function dependenciesES6() {
+  let glimmerEntries = ['@glimmer/node', '@glimmer/runtime'];
+  if (ENV === 'development') {
+    let hasGlimmerDebug = true;
+    try {
+      require('@glimmer/debug');
+    } catch (e) {
+      hasGlimmerDebug = false;
+    }
+    if (hasGlimmerDebug) {
+      glimmerEntries.push('@glimmer/debug', '@glimmer/local-debug-flags');
+    }
+  }
   return [
     dagES(),
     routerES(),
     routeRecognizerES(),
-    ...glimmerTrees(['@glimmer/node', '@glimmer/runtime']),
+    ...glimmerTrees(glimmerEntries),
   ];
 }
 

package.json

@@ -59,10 +59,13 @@
     "resolve": "^1.5.0"
   },
   "devDependencies": {
-    "@glimmer/compiler": "^0.25.6",
-    "@glimmer/node": "^0.25.6",
-    "@glimmer/reference": "^0.25.6",
-    "@glimmer/runtime": "^0.25.6",
+    "@glimmer/compiler": "^0.30.5",
+    "@glimmer/runtime": "^0.30.5",
+    "@glimmer/node": "^0.30.5",
+    "@glimmer/interfaces": "^0.30.5",
+    "@glimmer/reference": "^0.30.5",
+    "@glimmer/opcode-compiler": "^0.30.5",
+    "@glimmer/program": "^0.30.5",
     "@types/rsvp": "^4.0.1",
     "auto-dist-tag": "^0.1.5",
     "aws-sdk": "^2.46.0",
@@ -74,6 +77,7 @@
     "babel-plugin-transform-es2015-classes": "^6.24.1",
     "babel-plugin-transform-es2015-computed-properties": "^6.24.1",
     "babel-plugin-transform-es2015-destructuring": "^6.23.0",
+    "babel-plugin-transform-es2015-literals": "^6.22.0",
     "babel-plugin-transform-es2015-modules-amd": "^6.24.1",
     "babel-plugin-transform-es2015-parameters": "^6.24.1",
     "babel-plugin-transform-es2015-shorthand-properties": "^6.24.1",

packages/container/lib/index.d.ts

@@ -1,6 +1,7 @@
+import { Owner } from 'ember-utils';
 interface Container {
   registry: any;
-  owner: any | null;
+  owner: Owner | null;
   cache: any | null;
   factoryManagerCache: any | null;
   isDestroyed: boolean;
@@ -14,4 +15,5 @@ interface Container {
 }
 export const privatize: any;
 export const Registry: any;
-export const Container: (registry: any, options?: any) => Container;
+export const Container: (registry: any, options?: any) => Container;
+export const FACTORY_FOR: WeakMap<any, any>;

packages/ember-application/lib/system/engine-instance.js

@@ -179,6 +179,7 @@ const EngineInstance = EmberObject.extend(RegistryProxyMixin, ContainerProxyMixi
       '-view-registry:main',
       `renderer:-${env.isInteractive ? 'dom' : 'inert'}`,
       'service:-document',
+      P`template-options:main`,
     ];
 
     if (env.isInteractive) {

packages/ember-application/tests/system/application_test.js

@@ -164,7 +164,7 @@ moduleFor('Ember.Application', class extends ApplicationTestCase {
     verifyRegistration(assert, application, P`template:components/-default`);
     verifyRegistration(assert, application, 'template:-outlet');
     verifyInjection(assert, application, 'view:-outlet', 'template', 'template:-outlet');
-    verifyInjection(assert, application, 'template', 'env', 'service:-glimmer-environment');
+    verifyInjection(assert, application, 'template', 'options', P`template-options:main`);
 
     assert.deepEqual(application.registeredOptionsForType('helper'), { instantiate: false }, `optionsForType 'helper'`);
   }

packages/ember-application/tests/system/engine_test.js

@@ -77,7 +77,7 @@ moduleFor('Ember.Engine', class extends TestCase {
     verifyRegistration(assert, engine, P`template:components/-default`);
     verifyRegistration(assert, engine, 'template:-outlet');
     verifyInjection(assert, engine, 'view:-outlet', 'template', 'template:-outlet');
-    verifyInjection(assert, engine, 'template', 'env', 'service:-glimmer-environment');
+    verifyInjection(assert, engine, 'template', 'options', P`template-options:main`);
     assert.deepEqual(engine.registeredOptionsForType('helper'), { instantiate: false }, `optionsForType 'helper'`);
   }
 });

packages/ember-glimmer/lib/compile-time-lookup.ts

@@ -0,0 +1,51 @@
+import { ComponentCapabilities, Option, ProgramSymbolTable } from '@glimmer/interfaces';
+import { CompileTimeLookup as ICompileTimeLookup } from '@glimmer/opcode-compiler';
+import { CompilableTemplate, ComponentDefinition, ComponentManager, WithStaticLayout } from '@glimmer/runtime';
+import { OwnedTemplateMeta } from 'ember-views';
+import RuntimeResolver from './resolver';
+
+interface StaticComponentManager<DefinitionState> extends WithStaticLayout<any, DefinitionState, OwnedTemplateMeta, RuntimeResolver>,
+                                                          ComponentManager<any, DefinitionState> {
+}
+
+export default class CompileTimeLookup implements ICompileTimeLookup<OwnedTemplateMeta> {
+  constructor(private resolver: RuntimeResolver) {}
+
+  getCapabilities(handle: number): ComponentCapabilities {
+    let definition = this.resolver.resolve<Option<ComponentDefinition>>(handle);
+    let { manager, state } = definition!;
+    return manager.getCapabilities(state);
+  }
+
+  getLayout<DefinitionState>(handle: number): Option<CompilableTemplate<ProgramSymbolTable>> {
+    const { manager, state } = this.resolver.resolve<ComponentDefinition<DefinitionState, StaticComponentManager<DefinitionState>>>(handle);
+    const capabilities = manager.getCapabilities(state);
+
+    if (capabilities.dynamicLayout) {
+      return null;
+    }
+
+    const invocation = manager.getLayout(state, this.resolver);
+    return {
+      // TODO: this seems weird, it already is compiled
+      compile() { return invocation.handle; },
+      symbolTable: invocation.symbolTable
+    };
+  }
+
+  lookupHelper(name: string, referrer: OwnedTemplateMeta): Option<number> {
+    return this.resolver.lookupHelper(name, referrer);
+  }
+
+  lookupModifier(name: string, referrer: OwnedTemplateMeta): Option<number> {
+    return this.resolver.lookupModifier(name, referrer);
+  }
+
+  lookupComponentDefinition(name: string, referrer: OwnedTemplateMeta): Option<number> {
+    return this.resolver.lookupComponentDefinition(name, referrer);
+  }
+
+  lookupPartial(name: string, referrer: OwnedTemplateMeta): Option<number> {
+    return this.resolver.lookupPartial(name, referrer);
+  }
+}

packages/ember-glimmer/lib/component-managers/abstract.ts

@@ -1,16 +1,17 @@
-import { ProgramSymbolTable } from '@glimmer/interfaces';
+import {
+  ComponentCapabilities,
+  Simple,
+} from '@glimmer/interfaces';
 import { Tag, VersionedPathReference } from '@glimmer/reference';
 import {
+  Arguments,
   Bounds,
-  CompiledDynamicTemplate,
-  ComponentDefinition,
   ComponentManager,
   DynamicScope,
   ElementOperations,
   Environment,
   PreparedArguments,
 } from '@glimmer/runtime';
-import { IArguments } from '@glimmer/runtime/dist/types/lib/vm/arguments';
 import {
   Destroyable,
   Opaque,
@@ -23,7 +24,7 @@ import DebugStack from '../utils/debug-stack';
 // tslint:disable-next-line:max-line-length
 // https://github.com/glimmerjs/glimmer-vm/blob/v0.24.0-beta.4/packages/%40glimmer/runtime/lib/component/interfaces.ts#L21
 
-export default abstract class AbstractManager<T> implements ComponentManager<T> {
+export default abstract class AbstractManager<T, U> implements ComponentManager<T, U> {
   public debugStack: typeof DebugStack;
   public _pushToDebugStack: (name: string, environment: any) => void;
   public _pushEngineToDebugStack: (name: string, environment: any) => void;
@@ -32,7 +33,7 @@ export default abstract class AbstractManager<T> implements ComponentManager<T>
     this.debugStack = undefined;
   }
 
-  prepareArgs(_definition: ComponentDefinition<T>, _args: IArguments): Option<PreparedArguments> {
+  prepareArgs(_state: U, _args: Arguments): Option<PreparedArguments> {
     return null;
   }
 
@@ -42,18 +43,16 @@ export default abstract class AbstractManager<T> implements ComponentManager<T>
 
   abstract create(
     env: Environment,
-    definition: ComponentDefinition<T>,
-    args: IArguments,
+    definition: U,
+    args: Arguments,
     dynamicScope: DynamicScope,
     caller: VersionedPathReference<void | {}>,
     hasDefaultBlock: boolean): T;
-  abstract layoutFor(
-    definition: ComponentDefinition<T>,
-    component: T,
-    env: Environment): CompiledDynamicTemplate<ProgramSymbolTable>;
+
   abstract getSelf(component: T): VersionedPathReference<Opaque>;
+  abstract getCapabilities(state: U): ComponentCapabilities;
 
-  didCreateElement(_component: T, _element: Element, _operations: ElementOperations): void {
+  didCreateElement(_component: T, _element: Simple.Element, _operations: ElementOperations): void {
     // noop
   }
 
@@ -68,7 +67,7 @@ export default abstract class AbstractManager<T> implements ComponentManager<T>
     // noop
   }
 
-  getTag(_bucket: T): Option<Tag> { return null; }
+  abstract getTag(_bucket: T): Tag;
 
   // inheritors should also call `this._pushToDebugStack`
   // to ensure the rerendering assertion messages are