Finish implementing {{partial}}s

packages/@glimmer/compiler/lib/javascript-compiler.ts

@@ -324,8 +324,8 @@ export default class JavaScriptCompiler<T extends TemplateMeta> {
     this.pushValue<Expressions.Get>([Ops.Get, head, path]);
   }
 
-  doubtful(path: string[]) {
-    this.pushValue<Expressions.Doubtful>([Ops.Doubtful, path]);
+  maybeLocal(path: string[]) {
+    this.pushValue<Expressions.MaybeLocal>([Ops.MaybeLocal, path]);
   }
 
   concat() {

packages/@glimmer/compiler/lib/template-compiler.ts

@@ -191,7 +191,7 @@ export default class TemplateCompiler<T extends TemplateMeta> {
     } else if (isSimplePath(path)) {
       this.opcode('unknown', expr, path.parts[0]);
     } else {
-      this.opcode('doubtful', expr, path.parts);
+      this.opcode('maybeLocal', expr, path.parts);
     }
   }
 

packages/@glimmer/compiler/lib/template-visitor.ts

@@ -15,7 +15,6 @@ export abstract class SymbolTable {
 
   abstract allocateNamed(name: string): number;
   abstract allocateBlock(name: string): number;
-  abstract allocateEvalSlot(): number;
   abstract allocate(identifier: string): number;
 
   child(locals: string[]): BlockSymbolTable {
@@ -30,7 +29,6 @@ export class ProgramSymbolTable extends SymbolTable {
   private size = 1;
   private named = dict<number>();
   private blocks = dict<number>();
-  private evalSlot = null;
 
   has(name: string): boolean {
     return false;
@@ -68,16 +66,6 @@ export class ProgramSymbolTable extends SymbolTable {
     return block;
   }
 
-  allocateEvalSlot(): number {
-    let { evalSlot } = this;
-
-    if (!evalSlot) {
-      this.evalSlot = evalSlot = this.allocate('$eval');
-    }
-
-    return this.evalSlot;
-  }
-
   allocate(identifier: string): number {
     this.symbols.push(identifier);
     return this.size++;
@@ -117,10 +105,6 @@ export class BlockSymbolTable extends SymbolTable {
     return this.parent.allocateBlock(name);
   }
 
-  allocateEvalSlot(): number {
-    return this.parent.allocateEvalSlot();
-  }
-
   allocate(identifier: string): number {
     return this.parent.allocate(identifier);
   }

packages/@glimmer/interfaces/lib/tier1/symbol-table.d.ts

@@ -4,16 +4,27 @@ import { TemplateMeta } from '@glimmer/wire-format';
 export interface Symbols {
 }
 
+export interface CompilationMeta {
+  symbols: string[];
+  templateMeta: TemplateMeta;
+  asPartial: boolean;
+}
+
 export interface SymbolTable {
-  meta: TemplateMeta;
+  meta: CompilationMeta;
 }
 
 export interface ProgramSymbolTable extends SymbolTable {
+  hasEval: boolean;
   symbols: string[];
 }
 
 export interface BlockSymbolTable extends SymbolTable {
   parameters: number[];
 }
 
+export interface PartialSymbolTable extends SymbolTable {
+
+}
+
 export default SymbolTable;

packages/@glimmer/runtime/index.ts

@@ -73,7 +73,7 @@ export {
 
 export {
   ClientSide,
-  RawTemplate,
+  CompilableTemplate,
   ScannedBlock,
   ScannedProgram,
   Block,

packages/@glimmer/runtime/lib/compiled/opcodes/builder.ts

@@ -1,4 +1,3 @@
-import { TemplateMeta } from '@glimmer/wire-format';
 import * as content from './content';
 import * as vm from './vm';
 
@@ -11,7 +10,7 @@ import { ModifierManager } from '../../modifier/interfaces';
 import { ComponentDefinition } from '../../component/interfaces';
 import { PartialDefinition } from '../../partial';
 import Environment, { Program } from '../../environment';
-import { SymbolTable } from '@glimmer/interfaces';
+import { SymbolTable, CompilationMeta } from '@glimmer/interfaces';
 import { ComponentBuilder as IComponentBuilder } from '../../opcode-builder';
 import { ComponentBuilder } from '../../compiler';
 import { RawInlineBlock, ClientSide, Block } from '../../scanner';
@@ -81,7 +80,7 @@ export abstract class BasicOpcodeBuilder {
   private locals = 0;
   private _localsSize = 0;
 
-  constructor(public env: Environment, public meta: TemplateMeta, public program: Program) {
+  constructor(public env: Environment, public meta: CompilationMeta, public program: Program) {
     this.constants = env.constants;
     this.start = program.next;
 
@@ -146,21 +145,6 @@ export abstract class BasicOpcodeBuilder {
     label.patch(this.program);
   }
 
-  // partials
-
-  putPartialDefinition(_definition: PartialDefinition<Opaque>) {
-    let definition = this.constants.other(_definition);
-    this.push(Op.PutPartial, definition);
-  }
-
-  putDynamicPartialDefinition() {
-    // this.push(Op.PutDynamicPartial, this.constants.other(this.symbolTable));
-  }
-
-  evaluatePartial() {
-    // this.push(Op.EvaluatePartial, this.constants.other(this.symbolTable), this.constants.other(dict()));
-  }
-
   // components
 
   pushComponentManager(definition: ComponentDefinition<Opaque>) {
@@ -216,6 +200,16 @@ export abstract class BasicOpcodeBuilder {
     this.push(Op.DidRenderLayout, state);
   }
 
+  // partial
+
+  getPartialTemplate() {
+    this.push(Op.GetPartialTemplate);
+  }
+
+  resolveMaybeLocal(name: string) {
+    this.push(Op.ResolveMaybeLocal, this.string(name));
+  }
+
   // content
 
   dynamicContent(Opcode: content.AppendDynamicOpcode<Insertion>) {
@@ -381,14 +375,6 @@ export abstract class BasicOpcodeBuilder {
     this.push(Op.BindSelf);
   }
 
-  bindVirtualBlock(layout: number, block: number) {
-    this.push(Op.BindVirtualBlock, layout, block);
-  }
-
-  bindVirtualNamed(layout: number, name: string) {
-    this.push(Op.BindVirtualNamed, layout, this.string(name));
-  }
-
   pushRootScope(symbols: number, bindCallerScope: boolean) {
     this.push(Op.RootScope, symbols, <any>bindCallerScope|0);
   }
@@ -419,7 +405,7 @@ export abstract class BasicOpcodeBuilder {
     this.push(Op.PushReifiedArgs, positional, names, flag);
   }
 
-  pushImmediate(value: Opaque) {
+  pushImmediate<T>(value: T) {
     this.push(Op.Constant, this.other(value));
   }
 
@@ -516,28 +502,32 @@ export abstract class BasicOpcodeBuilder {
   invokeStatic(_block: Block, ...args: ((builder: BasicOpcodeBuilder) => void)[]): void;
   invokeStatic(_block: Block, numArgs: number): void;
   invokeStatic(_block: Block): void {
-    let paramSize = _block.symbolTable.parameters.length;
+    let { parameters } = _block.symbolTable;
+    let paramSize = parameters.length;
     let argSize = arguments.length - 1;
     let onStack = false;
+    let excess = 0;
 
     if (argSize === 1 && typeof arguments[1] === 'number') {
-      // BUG: what happens if paramSize < argSize?
-      // e.g. #with pushes 1 arg, #each pushes 2 - but the block might consume fewer
-      argSize = arguments[1];
+      argSize = Math.min(paramSize, arguments[1]);
+      excess = Math.max(arguments[1] - paramSize, 0);
       onStack = true;
     } else {
       argSize = Math.min(paramSize, argSize);
     }
 
+    for (let i=0; i<excess; i++) {
+      this.pop();
+    }
+
     if (argSize) {
-      let locals = _block.symbolTable.parameters;
       this.pushChildScope();
 
-      for (let i=0; i<argSize; i++) {
+      for (let i=argSize-1; i>=0; i--) {
         if (!onStack) {
           arguments[i+1](this);
         }
-        this.setVariable(locals[i]);
+        this.setVariable(parameters[i]);
       }
     }
 
@@ -616,7 +606,7 @@ function isCompilableExpression<E>(expr: Represents<E>): expr is CompilesInto<E>
 export default class OpcodeBuilder extends BasicOpcodeBuilder {
   public component: IComponentBuilder;
 
-  constructor(env: Environment, meta: TemplateMeta, program: Program = env.program) {
+  constructor(env: Environment, meta: CompilationMeta, program: Program = env.program) {
     super(env, meta, program);
     this.component = new ComponentBuilder(this);
   }

packages/@glimmer/runtime/lib/compiled/opcodes/expressions.ts

@@ -2,7 +2,6 @@ import { APPEND_OPCODES, Op } from '../../opcodes';
 import { ConcatReference } from '../expressions/concat';
 import { Helper } from '../../environment';
 import { EvaluatedArgs } from '../expressions/args';
-import { FunctionExpression } from '../expressions/function';
 import { TRUE_REFERENCE, FALSE_REFERENCE } from '../../references';
 import { VersionedPathReference } from '@glimmer/reference';
 import { Opaque } from '@glimmer/util';
@@ -31,6 +30,18 @@ APPEND_OPCODES.add(Op.SetVariable, (vm, { op1: symbol }) => {
   vm.scope().bindSymbol(symbol, expr);
 });
 
+APPEND_OPCODES.add(Op.ResolveMaybeLocal, (vm, { op1: _name }) => {
+  let name = vm.constants.getString(_name);
+  let locals = vm.scope().getPartialMap()!;
+
+  let ref = locals[name];
+  if (ref === undefined) {
+    ref = vm.getSelf().get(name);
+  }
+
+  vm.evalStack.push(ref);
+});
+
 APPEND_OPCODES.add(Op.RootScope, (vm, { op1: symbols, op2: bindCallerScope }) => {
   vm.pushRootScope(symbols, !!bindCallerScope);
 });

packages/@glimmer/runtime/lib/compiled/opcodes/partial.ts

@@ -1,50 +1,10 @@
-import { Opaque } from '@glimmer/util';
-import { ReferenceCache, isConst, map } from '@glimmer/reference';
-import { Assert } from './vm';
-import { SymbolTable } from '@glimmer/interfaces';
-import { APPEND_OPCODES, Op as Op } from '../../opcodes';
-
-APPEND_OPCODES.add(Op.PutDynamicPartial, (vm, { op1: _symbolTable }) => {
-  let env = vm.env;
-  let symbolTable = vm.constants.getOther<SymbolTable>(_symbolTable);
-
-  function lookupPartial(name: Opaque) {
-    let normalized = String(name);
-
-    if (!env.hasPartial(normalized, symbolTable)) {
-      throw new Error(`Could not find a partial named "${normalized}"`);
-    }
-
-    return env.lookupPartial(normalized, symbolTable);
-  }
-
-  let reference = map(vm.frame.getOperand<Opaque>(), lookupPartial);
-  let cache = isConst(reference) ? undefined : new ReferenceCache(reference);
-  let definition = cache ? cache.peek() : reference.value();
-
-  vm.frame.setImmediate(definition);
-
-  if (cache) {
-    vm.updateWith(new Assert(cache));
-  }
-});
-
-APPEND_OPCODES.add(Op.PutPartial, (_vm, { op1: _definition }) => {
-  // let definition = vm.constants.getOther<PartialDefinition<Opaque>>(_definition);
-  // vm.frame.setImmediate(definition);
-});
-
-APPEND_OPCODES.add(Op.EvaluatePartial, (_vm, { op1: _symbolTable, op2: _cache }) => {
-  // let symbolTable = vm.constants.getOther<SymbolTable>(_symbolTable);
-  // let cache = vm.constants.getOther<Dict<PartialBlock>>(_cache);
-
-  // let { template } = vm.frame.getImmediate<PartialDefinition<Opaque>>();
-
-  // let block = cache[template.id];
-
-  // if (!block) {
-  //   block = template.asPartial(symbolTable);
-  // }
-
-  // vm.invokePartial(block);
+import { TemplateMeta } from '@glimmer/wire-format';
+import { VersionedPathReference } from '@glimmer/reference';
+import { APPEND_OPCODES, Op } from '../../opcodes';
+import { PartialDefinition } from '../../partial';
+
+APPEND_OPCODES.add(Op.GetPartialTemplate, vm => {
+  let stack = vm.evalStack;
+  let definition = stack.pop<VersionedPathReference<PartialDefinition<TemplateMeta>>>();
+  stack.push(definition.value().template.asPartial());
 });

packages/@glimmer/runtime/lib/compiled/opcodes/vm.ts

@@ -15,8 +15,7 @@ import {
 } from '../expressions/args';
 
 import {
-  Block,
-  Program
+  Block
 } from '../../scanner';
 
 import {
@@ -124,29 +123,12 @@ APPEND_OPCODES.add(Op.BindNamedArgs, (vm, { op1: _names, op2: _symbols }) => {
   vm.bindNamedArgs(names, symbols);
 });
 
-APPEND_OPCODES.add(Op.BindVirtualBlock, (vm, { op1: _layout, op2: _block }) => {
-  let layout = vm.getLocal<Block>(_layout);
-  let symbol = layout.symbolTable.getSymbol('yields', _block ? 'inverse' : 'default')!;
-  vm.scope().bindBlock(symbol, vm.evalStack.pop<Block>());
-});
-
-APPEND_OPCODES.add(Op.BindVirtualNamed, (vm, { op1: _layout, op2: _name }) => {
-  let expr = vm.evalStack.pop<VersionedPathReference<Opaque>>();
-  let layout = vm.getLocal<Program>(_layout);
-  let symbol = layout.symbolTable.getSymbol('named', vm.constants.getString(_name))!;
-  vm.scope().bindSymbol(symbol, expr);
-});
-
 APPEND_OPCODES.add(Op.BindBlocks, (vm, { op1: _names, op2: _symbols }) => {
   let names = vm.constants.getArray(_names);
   let symbols = vm.constants.getArray(_symbols);
   vm.bindBlocks(names, symbols);
 });
 
-APPEND_OPCODES.add(Op.BindPartialArgs, (vm, { op1: symbol }) => {
-  vm.bindPartialArgs(symbol);
-});
-
 APPEND_OPCODES.add(Op.BindCallerScope, vm => vm.bindCallerScope());
 
 APPEND_OPCODES.add(Op.BindDynamicScope, (vm, { op1: _names }) => {