ember-source 5.7.0-alpha.2 → 5.7.0-alpha.4

package/dist/dependencies/@glimmer/opcode-compiler.js

@@ -1,6 +1,6 @@
 import { EMPTY_STRING_ARRAY, isSmallInt, encodeImmediate, unwrap, reverse, assert as assert$1, Stack, isPresentArray, encodeHandle, expect, assign, dict, enumerate, EMPTY_ARRAY, debugToString } from '@glimmer/util';
 import '@glimmer/debug';
-import { Op, MachineOp, $v0, $fp, $sp, InternalComponentCapabilities, $s0, ContentType, TYPE_SIZE, isMachineOp, MACHINE_MASK, $s1, ARG_SHIFT } from '@glimmer/vm';
+import { Op, MachineOp, $v0, $fp, $sp, InternalComponentCapabilities, $s0, ContentType, TYPE_SIZE, isMachineOp, MACHINE_MASK, ARG_SHIFT, $s1 } from '@glimmer/vm';
 import { DEBUG } from '@glimmer/env';
 import { InstructionEncoderImpl } from '@glimmer/encoder';
 import { SexpOpcodes } from '@glimmer/wire-format';
@@ -45,8 +45,7 @@ function assertResolverInvariants(meta) {
  * <Foo></Foo>
  * <Foo @arg={{true}} />
  */
-function resolveComponent(resolver, constants, meta, _ref) {
-  let [, expr, then] = _ref;
+function resolveComponent(resolver, constants, meta, [, expr, then]) {
   assert$1(isGetFreeComponent(expr), 'Attempted to resolve a component with incorrect opcode');
   let type = expr[0];
   if (DEBUG && expr[0] === SexpOpcodes.GetStrictKeyword) {
@@ -77,8 +76,7 @@ function resolveComponent(resolver, constants, meta, _ref) {
  * (helper)
  * (helper arg)
  */
-function resolveHelper(resolver, constants, meta, _ref2) {
-  let [, expr, then] = _ref2;
+function resolveHelper(resolver, constants, meta, [, expr, then]) {
   assert$1(isGetFreeHelper(expr), 'Attempted to resolve a helper with incorrect opcode');
   let type = expr[0];
   if (type === SexpOpcodes.GetLexicalSymbol) {
@@ -108,8 +106,7 @@ function resolveHelper(resolver, constants, meta, _ref2) {
  * <div {{modifier arg}}/>
  * <Foo {{modifier}}/>
  */
-function resolveModifier(resolver, constants, meta, _ref3) {
-  let [, expr, then] = _ref3;
+function resolveModifier(resolver, constants, meta, [, expr, then]) {
   assert$1(isGetFreeModifier(expr), 'Attempted to resolve a modifier with incorrect opcode');
   let type = expr[0];
   if (type === SexpOpcodes.GetLexicalSymbol) {
@@ -145,11 +142,10 @@ function resolveModifier(resolver, constants, meta, _ref3) {
 /**
  * {{component-or-helper arg}}
  */
-function resolveComponentOrHelper(resolver, constants, meta, _ref4) {
-  let [, expr, {
-    ifComponent,
-    ifHelper
-  }] = _ref4;
+function resolveComponentOrHelper(resolver, constants, meta, [, expr, {
+  ifComponent,
+  ifHelper
+}]) {
   assert$1(isGetFreeComponentOrHelper(expr), 'Attempted to resolve a component or helper with incorrect opcode');
   let type = expr[0];
   if (type === SexpOpcodes.GetLexicalSymbol) {
@@ -192,10 +188,9 @@ function resolveComponentOrHelper(resolver, constants, meta, _ref4) {
 /**
  * <Foo @arg={{helper}}>
  */
-function resolveOptionalHelper(resolver, constants, meta, _ref5) {
-  let [, expr, {
-    ifHelper
-  }] = _ref5;
+function resolveOptionalHelper(resolver, constants, meta, [, expr, {
+  ifHelper
+}]) {
   assert$1(isGetFreeOptionalHelper(expr) || isGetFreeDeprecatedHelper(expr), 'Attempted to resolve a helper with incorrect opcode');
   let {
     upvars,
@@ -211,12 +206,11 @@ function resolveOptionalHelper(resolver, constants, meta, _ref5) {
 /**
  * {{maybeHelperOrComponent}}
  */
-function resolveOptionalComponentOrHelper(resolver, constants, meta, _ref6) {
-  let [, expr, {
-    ifComponent,
-    ifHelper,
-    ifValue
-  }] = _ref6;
+function resolveOptionalComponentOrHelper(resolver, constants, meta, [, expr, {
+  ifComponent,
+  ifHelper,
+  ifValue
+}]) {
   assert$1(isGetFreeOptionalComponentOrHelper(expr), 'Attempted to resolve an optional component or helper with incorrect opcode');
   let type = expr[0];
   if (type === SexpOpcodes.GetLexicalSymbol) {
@@ -459,7 +453,7 @@ class EncoderImpl {
       return handle;
     }
   }
-  push(constants, type) {
+  push(constants, type, ...args) {
     let {
       heap
     } = this;
@@ -467,10 +461,10 @@ class EncoderImpl {
       throw new Error(`Opcode type over 8-bits. Got ${type}.`);
     }
     let machine = isMachineOp(type) ? MACHINE_MASK : 0;
-    let first = type | machine | (arguments.length <= 2 ? 0 : arguments.length - 2) << ARG_SHIFT;
+    let first = type | machine | args.length << ARG_SHIFT;
     heap.pushRaw(first);
-    for (let i = 0; i < (arguments.length <= 2 ? 0 : arguments.length - 2); i++) {
-      let op = i + 2 < 2 || arguments.length <= i + 2 ? undefined : arguments[i + 2];
+    for (let i = 0; i < args.length; i++) {
+      let op = args[i];
       heap.pushRaw(this.operand(constants, op));
     }
   }
@@ -695,15 +689,13 @@ class Compilers {
 }
 
 const EXPRESSIONS = new Compilers();
-EXPRESSIONS.add(SexpOpcodes.Concat, (op, _ref) => {
-  let [, parts] = _ref;
+EXPRESSIONS.add(SexpOpcodes.Concat, (op, [, parts]) => {
   for (let part of parts) {
     expr(op, part);
   }
   op(Op.Concat, parts.length);
 });
-EXPRESSIONS.add(SexpOpcodes.Call, (op, _ref2) => {
-  let [, expression, positional, named] = _ref2;
+EXPRESSIONS.add(SexpOpcodes.Call, (op, [, expression, positional, named]) => {
   if (isGetFreeHelper(expression)) {
     op(HighLevelResolutionOpcodes.Helper, expression, handle => {
       Call(op, handle, positional, named);
@@ -713,24 +705,20 @@ EXPRESSIONS.add(SexpOpcodes.Call, (op, _ref2) => {
     CallDynamic(op, positional, named);
   }
 });
-EXPRESSIONS.add(SexpOpcodes.Curry, (op, _ref3) => {
-  let [, expr, type, positional, named] = _ref3;
+EXPRESSIONS.add(SexpOpcodes.Curry, (op, [, expr, type, positional, named]) => {
   Curry(op, type, expr, positional, named);
 });
-EXPRESSIONS.add(SexpOpcodes.GetSymbol, (op, _ref4) => {
-  let [, sym, path] = _ref4;
+EXPRESSIONS.add(SexpOpcodes.GetSymbol, (op, [, sym, path]) => {
   op(Op.GetVariable, sym);
   withPath(op, path);
 });
-EXPRESSIONS.add(SexpOpcodes.GetLexicalSymbol, (op, _ref5) => {
-  let [, sym, path] = _ref5;
+EXPRESSIONS.add(SexpOpcodes.GetLexicalSymbol, (op, [, sym, path]) => {
   op(HighLevelResolutionOpcodes.TemplateLocal, sym, handle => {
     op(Op.ConstantReference, handle);
     withPath(op, path);
   });
 });
-EXPRESSIONS.add(SexpOpcodes.GetStrictKeyword, (op, _ref6) => {
-  let [, sym, _path] = _ref6;
+EXPRESSIONS.add(SexpOpcodes.GetStrictKeyword, (op, [, sym, _path]) => {
   op(HighLevelResolutionOpcodes.Free, sym, _handle => {
     // TODO: Implement in strict mode
   });
@@ -776,38 +764,32 @@ function withPath(op, path) {
   }
 }
 EXPRESSIONS.add(SexpOpcodes.Undefined, op => PushPrimitiveReference(op, undefined));
-EXPRESSIONS.add(SexpOpcodes.HasBlock, (op, _ref7) => {
-  let [, block] = _ref7;
+EXPRESSIONS.add(SexpOpcodes.HasBlock, (op, [, block]) => {
   expr(op, block);
   op(Op.HasBlock);
 });
-EXPRESSIONS.add(SexpOpcodes.HasBlockParams, (op, _ref8) => {
-  let [, block] = _ref8;
+EXPRESSIONS.add(SexpOpcodes.HasBlockParams, (op, [, block]) => {
   expr(op, block);
   op(Op.SpreadBlock);
   op(Op.CompileBlock);
   op(Op.HasBlockParams);
 });
-EXPRESSIONS.add(SexpOpcodes.IfInline, (op, _ref9) => {
-  let [, condition, truthy, falsy] = _ref9;
+EXPRESSIONS.add(SexpOpcodes.IfInline, (op, [, condition, truthy, falsy]) => {
   // Push in reverse order
   expr(op, falsy);
   expr(op, truthy);
   expr(op, condition);
   op(Op.IfInline);
 });
-EXPRESSIONS.add(SexpOpcodes.Not, (op, _ref10) => {
-  let [, value] = _ref10;
+EXPRESSIONS.add(SexpOpcodes.Not, (op, [, value]) => {
   expr(op, value);
   op(Op.Not);
 });
-EXPRESSIONS.add(SexpOpcodes.GetDynamicVar, (op, _ref11) => {
-  let [, expression] = _ref11;
+EXPRESSIONS.add(SexpOpcodes.GetDynamicVar, (op, [, expression]) => {
   expr(op, expression);
   op(Op.GetDynamicVar);
 });
-EXPRESSIONS.add(SexpOpcodes.Log, (op, _ref12) => {
-  let [, positional] = _ref12;
+EXPRESSIONS.add(SexpOpcodes.Log, (op, [, positional]) => {
   op(MachineOp.PushFrame);
   SimpleArgs(op, positional, null, false);
   op(Op.Log);
@@ -1254,15 +1236,14 @@ function InvokeDynamicComponent(op, definition, _elementBlock, positional, named
     op(HighLevelBuilderOpcodes.Label, 'ELSE');
   });
 }
-function InvokeStaticComponent(op, _ref) {
-  let {
-    capabilities,
-    layout,
-    elementBlock,
-    positional,
-    named,
-    blocks
-  } = _ref;
+function InvokeStaticComponent(op, {
+  capabilities,
+  layout,
+  elementBlock,
+  positional,
+  named,
+  blocks
+}) {
   let {
     symbolTable
   } = layout;
@@ -1425,16 +1406,15 @@ function InvokeStaticComponent(op, _ref) {
   op(Op.CommitComponentTransaction);
   op(Op.Load, $s0);
 }
-function InvokeNonStaticComponent(op, _ref2) {
-  let {
-    capabilities,
-    elementBlock,
-    positional,
-    named,
-    atNames,
-    blocks: namedBlocks,
-    layout
-  } = _ref2;
+function InvokeNonStaticComponent(op, {
+  capabilities,
+  elementBlock,
+  positional,
+  named,
+  atNames,
+  blocks: namedBlocks,
+  layout
+}) {
   let bindableBlocks = !!namedBlocks;
   let bindableAtNames = capabilities === true || hasCapability(capabilities, InternalComponentCapabilities.prepareArgs) || !!(named && named[0].length !== 0);
   let blocks = namedBlocks.with('attrs', elementBlock);
@@ -1479,8 +1459,7 @@ function WrappedComponent(op, layout, attrsBlockNumber) {
   op(Op.Load, $s1);
   op(HighLevelBuilderOpcodes.StopLabels);
 }
-function invokePreparedComponent(op, hasBlock, bindableBlocks, bindableAtNames) {
-  let populateLayout = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : null;
+function invokePreparedComponent(op, hasBlock, bindableBlocks, bindableAtNames, populateLayout = null) {
   op(Op.BeginComponentTransaction, $s0);
   op(Op.PushDynamicScope);
   op(Op.CreateComponent, hasBlock | 0, $s0);
@@ -1609,10 +1588,7 @@ function build(program, builder) {
     resolver
   } = program;
   let encoder = new EncoderImpl(heap, STDLIB_META);
-  function pushOp() {
-    for (var _len = arguments.length, op = new Array(_len), _key = 0; _key < _len; _key++) {
-      op[_key] = arguments[_key];
-    }
+  function pushOp(...op) {
     encodeOp(encoder, constants, resolver, STDLIB_META, op);
   }
   builder(pushOp);
@@ -1629,11 +1605,10 @@ class CompileTimeCompilationContextImpl {
   constants;
   heap;
   stdlib;
-  constructor(_ref, resolver, createOp) {
-    let {
-      constants,
-      heap
-    } = _ref;
+  constructor({
+    constants,
+    heap
+  }, resolver, createOp) {
     this.resolver = resolver;
     this.createOp = createOp;
     this.constants = constants;
@@ -1666,8 +1641,7 @@ function inflateAttrName(attrName) {
 STATEMENTS.add(SexpOpcodes.Comment, (op, sexp) => op(Op.Comment, sexp[1]));
 STATEMENTS.add(SexpOpcodes.CloseElement, op => op(Op.CloseElement));
 STATEMENTS.add(SexpOpcodes.FlushElement, op => op(Op.FlushElement));
-STATEMENTS.add(SexpOpcodes.Modifier, (op, _ref) => {
-  let [, expression, positional, named] = _ref;
+STATEMENTS.add(SexpOpcodes.Modifier, (op, [, expression, positional, named]) => {
   if (isGetFreeModifier(expression)) {
     op(HighLevelResolutionOpcodes.Modifier, expression, handle => {
       op(MachineOp.PushFrame);
@@ -1684,45 +1658,36 @@ STATEMENTS.add(SexpOpcodes.Modifier, (op, _ref) => {
     op(MachineOp.PopFrame);
   }
 });
-STATEMENTS.add(SexpOpcodes.StaticAttr, (op, _ref2) => {
-  let [, name, value, namespace] = _ref2;
+STATEMENTS.add(SexpOpcodes.StaticAttr, (op, [, name, value, namespace]) => {
   op(Op.StaticAttr, inflateAttrName(name), value, namespace ?? null);
 });
-STATEMENTS.add(SexpOpcodes.StaticComponentAttr, (op, _ref3) => {
-  let [, name, value, namespace] = _ref3;
+STATEMENTS.add(SexpOpcodes.StaticComponentAttr, (op, [, name, value, namespace]) => {
   op(Op.StaticComponentAttr, inflateAttrName(name), value, namespace ?? null);
 });
-STATEMENTS.add(SexpOpcodes.DynamicAttr, (op, _ref4) => {
-  let [, name, value, namespace] = _ref4;
+STATEMENTS.add(SexpOpcodes.DynamicAttr, (op, [, name, value, namespace]) => {
   expr(op, value);
   op(Op.DynamicAttr, inflateAttrName(name), false, namespace ?? null);
 });
-STATEMENTS.add(SexpOpcodes.TrustingDynamicAttr, (op, _ref5) => {
-  let [, name, value, namespace] = _ref5;
+STATEMENTS.add(SexpOpcodes.TrustingDynamicAttr, (op, [, name, value, namespace]) => {
   expr(op, value);
   op(Op.DynamicAttr, inflateAttrName(name), true, namespace ?? null);
 });
-STATEMENTS.add(SexpOpcodes.ComponentAttr, (op, _ref6) => {
-  let [, name, value, namespace] = _ref6;
+STATEMENTS.add(SexpOpcodes.ComponentAttr, (op, [, name, value, namespace]) => {
   expr(op, value);
   op(Op.ComponentAttr, inflateAttrName(name), false, namespace ?? null);
 });
-STATEMENTS.add(SexpOpcodes.TrustingComponentAttr, (op, _ref7) => {
-  let [, name, value, namespace] = _ref7;
+STATEMENTS.add(SexpOpcodes.TrustingComponentAttr, (op, [, name, value, namespace]) => {
   expr(op, value);
   op(Op.ComponentAttr, inflateAttrName(name), true, namespace ?? null);
 });
-STATEMENTS.add(SexpOpcodes.OpenElement, (op, _ref8) => {
-  let [, tag] = _ref8;
+STATEMENTS.add(SexpOpcodes.OpenElement, (op, [, tag]) => {
   op(Op.OpenElement, inflateTagName(tag));
 });
-STATEMENTS.add(SexpOpcodes.OpenElementWithSplat, (op, _ref9) => {
-  let [, tag] = _ref9;
+STATEMENTS.add(SexpOpcodes.OpenElementWithSplat, (op, [, tag]) => {
   op(Op.PutComponentOperations);
   op(Op.OpenElement, inflateTagName(tag));
 });
-STATEMENTS.add(SexpOpcodes.Component, (op, _ref10) => {
-  let [, expr, elementBlock, named, blocks] = _ref10;
+STATEMENTS.add(SexpOpcodes.Component, (op, [, expr, elementBlock, named, blocks]) => {
   if (isGetFreeComponent(expr)) {
     op(HighLevelResolutionOpcodes.Component, expr, component => {
       InvokeComponent(op, component, elementBlock, null, named, blocks);
@@ -1733,20 +1698,10 @@ STATEMENTS.add(SexpOpcodes.Component, (op, _ref10) => {
     InvokeDynamicComponent(op, expr, elementBlock, null, named, blocks, true, true);
   }
 });
-STATEMENTS.add(SexpOpcodes.Yield, (op, _ref11) => {
-  let [, to, params] = _ref11;
-  return YieldBlock(op, to, params);
-});
-STATEMENTS.add(SexpOpcodes.AttrSplat, (op, _ref12) => {
-  let [, to] = _ref12;
-  return YieldBlock(op, to, null);
-});
-STATEMENTS.add(SexpOpcodes.Debugger, (op, _ref13) => {
-  let [, debugInfo] = _ref13;
-  return op(Op.Debugger, debugSymbolsOperand(), debugInfo);
-});
-STATEMENTS.add(SexpOpcodes.Append, (op, _ref14) => {
-  let [, value] = _ref14;
+STATEMENTS.add(SexpOpcodes.Yield, (op, [, to, params]) => YieldBlock(op, to, params));
+STATEMENTS.add(SexpOpcodes.AttrSplat, (op, [, to]) => YieldBlock(op, to, null));
+STATEMENTS.add(SexpOpcodes.Debugger, (op, [, debugInfo]) => op(Op.Debugger, debugSymbolsOperand(), debugInfo));
+STATEMENTS.add(SexpOpcodes.Append, (op, [, value]) => {
   // Special case for static values
   if (!Array.isArray(value)) {
     op(Op.Text, value === null || value === undefined ? '' : String(value));
@@ -1813,8 +1768,7 @@ STATEMENTS.add(SexpOpcodes.Append, (op, _ref14) => {
     op(MachineOp.PopFrame);
   }
 });
-STATEMENTS.add(SexpOpcodes.TrustingAppend, (op, _ref15) => {
-  let [, value] = _ref15;
+STATEMENTS.add(SexpOpcodes.TrustingAppend, (op, [, value]) => {
   if (!Array.isArray(value)) {
     op(Op.Text, value === null || value === undefined ? '' : String(value));
   } else {
@@ -1824,8 +1778,7 @@ STATEMENTS.add(SexpOpcodes.TrustingAppend, (op, _ref15) => {
     op(MachineOp.PopFrame);
   }
 });
-STATEMENTS.add(SexpOpcodes.Block, (op, _ref16) => {
-  let [, expr, positional, named, blocks] = _ref16;
+STATEMENTS.add(SexpOpcodes.Block, (op, [, expr, positional, named, blocks]) => {
   if (isGetFreeComponent(expr)) {
     op(HighLevelResolutionOpcodes.Component, expr, component => {
       InvokeComponent(op, component, null, positional, hashToArgs(named), blocks);
@@ -1834,8 +1787,7 @@ STATEMENTS.add(SexpOpcodes.Block, (op, _ref16) => {
     InvokeDynamicComponent(op, expr, null, positional, named, blocks, false, false);
   }
 });
-STATEMENTS.add(SexpOpcodes.InElement, (op, _ref17) => {
-  let [, block, guid, destination, insertBefore] = _ref17;
+STATEMENTS.add(SexpOpcodes.InElement, (op, [, block, guid, destination, insertBefore]) => {
   ReplayableIf(op, () => {
     expr(op, guid);
     if (insertBefore === undefined) {
@@ -1852,51 +1804,44 @@ STATEMENTS.add(SexpOpcodes.InElement, (op, _ref17) => {
     op(Op.PopRemoteElement);
   });
 });
-STATEMENTS.add(SexpOpcodes.If, (op, _ref18) => {
-  let [, condition, block, inverse] = _ref18;
-  return ReplayableIf(op, () => {
-    expr(op, condition);
-    op(Op.ToBoolean);
-    return 1;
-  }, () => {
-    InvokeStaticBlock(op, block);
-  }, inverse ? () => {
+STATEMENTS.add(SexpOpcodes.If, (op, [, condition, block, inverse]) => ReplayableIf(op, () => {
+  expr(op, condition);
+  op(Op.ToBoolean);
+  return 1;
+}, () => {
+  InvokeStaticBlock(op, block);
+}, inverse ? () => {
+  InvokeStaticBlock(op, inverse);
+} : undefined));
+STATEMENTS.add(SexpOpcodes.Each, (op, [, value, key, block, inverse]) => Replayable(op, () => {
+  if (key) {
+    expr(op, key);
+  } else {
+    PushPrimitiveReference(op, null);
+  }
+  expr(op, value);
+  return 2;
+}, () => {
+  op(Op.EnterList, labelOperand('BODY'), labelOperand('ELSE'));
+  op(MachineOp.PushFrame);
+  op(Op.Dup, $fp, 1);
+  op(MachineOp.ReturnTo, labelOperand('ITER'));
+  op(HighLevelBuilderOpcodes.Label, 'ITER');
+  op(Op.Iterate, labelOperand('BREAK'));
+  op(HighLevelBuilderOpcodes.Label, 'BODY');
+  InvokeStaticBlockWithStack(op, block, 2);
+  op(Op.Pop, 2);
+  op(MachineOp.Jump, labelOperand('FINALLY'));
+  op(HighLevelBuilderOpcodes.Label, 'BREAK');
+  op(MachineOp.PopFrame);
+  op(Op.ExitList);
+  op(MachineOp.Jump, labelOperand('FINALLY'));
+  op(HighLevelBuilderOpcodes.Label, 'ELSE');
+  if (inverse) {
     InvokeStaticBlock(op, inverse);
-  } : undefined);
-});
-STATEMENTS.add(SexpOpcodes.Each, (op, _ref19) => {
-  let [, value, key, block, inverse] = _ref19;
-  return Replayable(op, () => {
-    if (key) {
-      expr(op, key);
-    } else {
-      PushPrimitiveReference(op, null);
-    }
-    expr(op, value);
-    return 2;
-  }, () => {
-    op(Op.EnterList, labelOperand('BODY'), labelOperand('ELSE'));
-    op(MachineOp.PushFrame);
-    op(Op.Dup, $fp, 1);
-    op(MachineOp.ReturnTo, labelOperand('ITER'));
-    op(HighLevelBuilderOpcodes.Label, 'ITER');
-    op(Op.Iterate, labelOperand('BREAK'));
-    op(HighLevelBuilderOpcodes.Label, 'BODY');
-    InvokeStaticBlockWithStack(op, block, 2);
-    op(Op.Pop, 2);
-    op(MachineOp.Jump, labelOperand('FINALLY'));
-    op(HighLevelBuilderOpcodes.Label, 'BREAK');
-    op(MachineOp.PopFrame);
-    op(Op.ExitList);
-    op(MachineOp.Jump, labelOperand('FINALLY'));
-    op(HighLevelBuilderOpcodes.Label, 'ELSE');
-    if (inverse) {
-      InvokeStaticBlock(op, inverse);
-    }
-  });
-});
-STATEMENTS.add(SexpOpcodes.With, (op, _ref20) => {
-  let [, value, block, inverse] = _ref20;
+  }
+}));
+STATEMENTS.add(SexpOpcodes.With, (op, [, value, block, inverse]) => {
   ReplayableIf(op, () => {
     expr(op, value);
     op(Op.Dup, $sp, 0);
@@ -1910,13 +1855,11 @@ STATEMENTS.add(SexpOpcodes.With, (op, _ref20) => {
     }
   });
 });
-STATEMENTS.add(SexpOpcodes.Let, (op, _ref21) => {
-  let [, positional, block] = _ref21;
+STATEMENTS.add(SexpOpcodes.Let, (op, [, positional, block]) => {
   let count = CompilePositional(op, positional);
   InvokeStaticBlockWithStack(op, block, count);
 });
-STATEMENTS.add(SexpOpcodes.WithDynamicVars, (op, _ref22) => {
-  let [, named, block] = _ref22;
+STATEMENTS.add(SexpOpcodes.WithDynamicVars, (op, [, named, block]) => {
   if (named) {
     let [names, expressions] = named;
     CompilePositional(op, expressions);
@@ -1927,8 +1870,7 @@ STATEMENTS.add(SexpOpcodes.WithDynamicVars, (op, _ref22) => {
     InvokeStaticBlock(op, block);
   }
 });
-STATEMENTS.add(SexpOpcodes.InvokeComponent, (op, _ref23) => {
-  let [, expr, positional, named, blocks] = _ref23;
+STATEMENTS.add(SexpOpcodes.InvokeComponent, (op, [, expr, positional, named, blocks]) => {
   if (isGetFreeComponent(expr)) {
     op(HighLevelResolutionOpcodes.Component, expr, component => {
       InvokeComponent(op, component, null, positional, hashToArgs(named), blocks);
@@ -1948,8 +1890,9 @@ class CompilableTemplateImpl {
   compiled = null;
   constructor(statements, meta,
   // Part of CompilableTemplate
-  symbolTable) {
-    let moduleName = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 'plain block';
+  symbolTable,
+  // Used for debugging
+  moduleName = 'plain block') {
     this.statements = statements;
     this.meta = meta;
     this.symbolTable = symbolTable;
@@ -1989,10 +1932,7 @@ function compileStatements(statements, meta, syntaxContext) {
       resolver
     }
   } = context;
-  function pushOp() {
-    for (var _len = arguments.length, op = new Array(_len), _key = 0; _key < _len; _key++) {
-      op[_key] = arguments[_key];
-    }
+  function pushOp(...op) {
     encodeOp(encoder, constants, resolver, meta, op);
   }
   for (const statement of statements) {
@@ -2074,10 +2014,7 @@ class WrappedBuilder {
         resolver
       }
     } = context;
-    function pushOp() {
-      for (var _len = arguments.length, op = new Array(_len), _key = 0; _key < _len; _key++) {
-        op[_key] = arguments[_key];
-      }
+    function pushOp(...op) {
       encodeOp(encoder, constants, resolver, m, op);
     }
     WrappedComponent(pushOp, this.layout, this.attrsBlockNumber);
@@ -2103,14 +2040,13 @@ let templateCacheCounters = {
  * that handles lazy parsing the template and to create per env singletons
  * of the template.
  */
-function templateFactory(_ref) {
-  let {
-    id: templateId,
-    moduleName,
-    block,
-    scope,
-    isStrictMode
-  } = _ref;
+function templateFactory({
+  id: templateId,
+  moduleName,
+  block,
+  scope,
+  isStrictMode
+}) {
   // TODO(template-refactors): This should be removed in the near future, as it
   // appears that id is unused. It is currently kept for backwards compat reasons.
   let id = templateId || `client-${clientId++}`;

package/dist/dependencies/@glimmer/program.js

@@ -79,8 +79,9 @@ class ConstantsImpl extends CompileTimeConstantImpl {
   helperDefinitionCache = new WeakMap();
   modifierDefinitionCache = new WeakMap();
   componentDefinitionCache = new WeakMap();
-  helper(definitionState) {
-    let isOptional = arguments.length > 2 ? arguments[2] : undefined;
+  helper(definitionState,
+  // TODO: Add a way to expose resolved name for debugging
+  _resolvedName = null, isOptional) {
     let handle = this.helperDefinitionCache.get(definitionState);
     if (handle === undefined) {
       let managerOrHelper = getInternalHelperManager(definitionState, isOptional);
@@ -96,9 +97,7 @@ class ConstantsImpl extends CompileTimeConstantImpl {
     }
     return handle;
   }
-  modifier(definitionState) {
-    let resolvedName = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
-    let isOptional = arguments.length > 2 ? arguments[2] : undefined;
+  modifier(definitionState, resolvedName = null, isOptional) {
     let handle = this.modifierDefinitionCache.get(definitionState);
     if (handle === undefined) {
       let manager = getInternalModifierManager(definitionState, isOptional);
@@ -387,8 +386,7 @@ class HeapImpl {
     }
     this.offset = this.offset - compactedSize;
   }
-  capture() {
-    let offset = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.offset;
+  capture(offset = this.offset) {
     // Only called in eager mode
     let buffer = slice(this.heap, 0, offset).buffer;
     return {

package/dist/dependencies/@glimmer/reference.js

@@ -1,5 +1,5 @@
 import { DEBUG } from '@glimmer/env';
-import { getProp, toIterator, setProp, getPath } from '@glimmer/global-context';
+import { setProp, getProp, toIterator, getPath } from '@glimmer/global-context';
 import { expect, isDict, EMPTY_ARRAY, isObject } from '@glimmer/util';
 import { CONSTANT_TAG, validateTag, track, valueForTag, consumeTag, createTag, dirtyTag, INITIAL } from '@glimmer/validator';
 
@@ -55,9 +55,7 @@ function createUnboundRef(value, debugLabel) {
   }
   return ref;
 }
-function createComputeRef(compute) {
-  let update = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
-  let debugLabel = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 'unknown';
+function createComputeRef(compute, update = null, debugLabel = 'unknown') {
   const ref = new ReferenceImpl(COMPUTE);
   ref.compute = compute;
   ref.update = update;