ember-source 5.9.0-alpha.6 → 5.9.0-beta.1

package/build-metadata.json

@@ -1,6 +1,6 @@
 {
-  "version": "5.9.0-alpha.6",
+  "version": "5.9.0-beta.1",
   "buildType": "tag",
-  "SHA": "12078ad30ea13b3b2620d88a51babf0a494020b4",
-  "assetPath": "/tag/shas/12078ad30ea13b3b2620d88a51babf0a494020b4.tgz"
+  "SHA": "79111462575293d5ad9cf9e101a69012fab13dea",
+  "assetPath": "/tag/shas/79111462575293d5ad9cf9e101a69012fab13dea.tgz"
 }

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

@@ -1300,6 +1300,14 @@ class NullChecker {
     return `null`;
   }
 }
+class UndefinedChecker {
+  validate(value) {
+    return value === undefined;
+  }
+  expected() {
+    return `undefined`;
+  }
+}
 class InstanceofChecker {
   constructor(Class) {
     this.Class = Class;
@@ -1483,6 +1491,7 @@ const CheckBoolean = new TypeofChecker('boolean');
 const CheckHandle = CheckNumber;
 const CheckString = new TypeofChecker('string');
 const CheckNull = new NullChecker();
+const CheckUndefined = new UndefinedChecker();
 const CheckUnknown = new OpaqueChecker();
 const CheckSafeString = new SafeStringChecker();
 const CheckObject = new ObjectChecker();
@@ -1513,4 +1522,4 @@ const CheckNode = CheckInterface({
   nextSibling: CheckUnknown
 });
 
-export { CheckArray, CheckBlockSymbolTable, CheckBoolean, CheckDict, CheckDocumentFragment, CheckElement, CheckFunction, CheckHandle, CheckInstanceof, CheckInterface, CheckMaybe, CheckNode, CheckNull, CheckNumber, CheckObject, CheckOption, CheckOr, CheckPrimitive, CheckProgramSymbolTable, CheckSafeString, CheckString, CheckUnknown, CheckValue, META_KIND, OPERAND_TYPES, buildEnum, buildMetas, buildSingleMeta, check, debug, debugSlice, expectStackChange, logOpcode, normalize, normalizeAll, normalizeParsed, opcodeMetadata, recordStackSize, strip, wrap };
+export { CheckArray, CheckBlockSymbolTable, CheckBoolean, CheckDict, CheckDocumentFragment, CheckElement, CheckFunction, CheckHandle, CheckInstanceof, CheckInterface, CheckMaybe, CheckNode, CheckNull, CheckNumber, CheckObject, CheckOption, CheckOr, CheckPrimitive, CheckProgramSymbolTable, CheckSafeString, CheckString, CheckUndefined, CheckUnknown, CheckValue, META_KIND, OPERAND_TYPES, buildEnum, buildMetas, buildSingleMeta, check, debug, debugSlice, expectStackChange, logOpcode, normalize, normalizeAll, normalizeParsed, opcodeMetadata, recordStackSize, strip, wrap };

package/dist/dependencies/@glimmer/global-context.js

@@ -23,7 +23,9 @@ import { DEBUG } from '@glimmer/env';
  * TODO: Move these into @glimmer/interfaces, move @glimmer/interfaces to
  * @glimmer/internal-interfaces.
  */
+
 //////////
+
 /**
  * Schedules a VM revalidation.
  *

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

@@ -603,16 +603,20 @@ class CustomModifierManager {
       args,
       modifier: instance
     };
-    if (DEBUG) {
-      state.debugName = typeof definition === 'function' ? definition.name : definition.toString();
-    }
     registerDestructor(state, () => delegate.destroyModifier(instance, args));
     return state;
   }
-  getDebugName({
-    debugName
+  getDebugName(definition) {
+    if (typeof definition === 'function') {
+      return definition.name || definition.toString();
+    } else {
+      return '<unknown>';
+    }
+  }
+  getDebugInstance({
+    modifier
   }) {
-    return debugName;
+    return modifier;
   }
   getTag({
     tag

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

@@ -1,11 +1,10 @@
-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 { EMPTY_STRING_ARRAY, isSmallInt, encodeImmediate, unwrap, reverse, assert, 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, ARG_SHIFT, $s1 } from '@glimmer/vm';
 import { DEBUG } from '@glimmer/env';
 import { InstructionEncoderImpl } from '@glimmer/encoder';
 import { SexpOpcodes } from '@glimmer/wire-format';
 import { hasCapability } from '@glimmer/manager';
-import { assert, deprecate } from '@glimmer/global-context';
 
 let debugCompiler;
 
@@ -23,11 +22,6 @@ const isGetFreeComponent = makeResolutionTypeVerifier(SexpOpcodes.GetFreeAsCompo
 const isGetFreeModifier = makeResolutionTypeVerifier(SexpOpcodes.GetFreeAsModifierHead);
 const isGetFreeHelper = makeResolutionTypeVerifier(SexpOpcodes.GetFreeAsHelperHead);
 const isGetFreeComponentOrHelper = makeResolutionTypeVerifier(SexpOpcodes.GetFreeAsComponentOrHelperHead);
-const isGetFreeOptionalHelper = makeResolutionTypeVerifier(SexpOpcodes.GetFreeAsHelperHeadOrThisFallback);
-function isGetFreeDeprecatedHelper(opcode) {
-  return Array.isArray(opcode) && opcode[0] === SexpOpcodes.GetFreeAsDeprecatedHelperHeadOrThisFallback;
-}
-const isGetFreeOptionalComponentOrHelper = makeResolutionTypeVerifier(SexpOpcodes.GetFreeAsComponentOrHelperHeadOrThisFallback);
 function assertResolverInvariants(meta) {
   if (DEBUG) {
     if (!meta.upvars) {
@@ -46,9 +40,10 @@ function assertResolverInvariants(meta) {
  * <Foo @arg={{true}} />
  */
 function resolveComponent(resolver, constants, meta, [, expr, then]) {
-  assert$1(isGetFreeComponent(expr), 'Attempted to resolve a component with incorrect opcode');
+  assert(isGetFreeComponent(expr), 'Attempted to resolve a component with incorrect opcode');
   let type = expr[0];
   if (DEBUG && expr[0] === SexpOpcodes.GetStrictKeyword) {
+    assert(!meta.isStrictMode, 'Strict mode errors should already be handled at compile time');
     throw new Error(`Attempted to resolve a component in a strict mode template, but that value was not in scope: ${meta.upvars[expr[1]] ?? '{unknown variable}'}`);
   }
   if (type === SexpOpcodes.GetLexicalSymbol) {
@@ -66,6 +61,7 @@ function resolveComponent(resolver, constants, meta, [, expr, then]) {
     let name = unwrap(upvars[expr[1]]);
     let definition = resolver.lookupComponent(name, owner);
     if (DEBUG && (typeof definition !== 'object' || definition === null)) {
+      assert(!meta.isStrictMode, 'Strict mode errors should already be handled at compile time');
       throw new Error(`Attempted to resolve \`${name}\`, which was expected to be a component, but nothing was found.`);
     }
     then(constants.resolvedComponent(definition, name));
@@ -77,7 +73,7 @@ function resolveComponent(resolver, constants, meta, [, expr, then]) {
  * (helper arg)
  */
 function resolveHelper(resolver, constants, meta, [, expr, then]) {
-  assert$1(isGetFreeHelper(expr), 'Attempted to resolve a helper with incorrect opcode');
+  assert(isGetFreeHelper(expr), 'Attempted to resolve a helper with incorrect opcode');
   let type = expr[0];
   if (type === SexpOpcodes.GetLexicalSymbol) {
     let {
@@ -95,6 +91,7 @@ function resolveHelper(resolver, constants, meta, [, expr, then]) {
     let name = unwrap(upvars[expr[1]]);
     let helper = resolver.lookupHelper(name, owner);
     if (DEBUG && helper === null) {
+      assert(!meta.isStrictMode, 'Strict mode errors should already be handled at compile time');
       throw new Error(`Attempted to resolve \`${name}\`, which was expected to be a helper, but nothing was found.`);
     }
     then(constants.helper(helper, name));
@@ -107,7 +104,7 @@ function resolveHelper(resolver, constants, meta, [, expr, then]) {
  * <Foo {{modifier}}/>
  */
 function resolveModifier(resolver, constants, meta, [, expr, then]) {
-  assert$1(isGetFreeModifier(expr), 'Attempted to resolve a modifier with incorrect opcode');
+  assert(isGetFreeModifier(expr), 'Attempted to resolve a modifier with incorrect opcode');
   let type = expr[0];
   if (type === SexpOpcodes.GetLexicalSymbol) {
     let {
@@ -122,6 +119,7 @@ function resolveModifier(resolver, constants, meta, [, expr, then]) {
     let name = unwrap(upvars[expr[1]]);
     let modifier = resolver.lookupBuiltInModifier(name);
     if (DEBUG && modifier === null) {
+      assert(!meta.isStrictMode, 'Strict mode errors should already be handled at compile time');
       throw new Error(`Attempted to resolve a modifier in a strict mode template, but it was not in scope: ${name}`);
     }
     then(constants.modifier(modifier, name));
@@ -133,6 +131,7 @@ function resolveModifier(resolver, constants, meta, [, expr, then]) {
     let name = unwrap(upvars[expr[1]]);
     let modifier = resolver.lookupModifier(name, owner);
     if (DEBUG && modifier === null) {
+      assert(!meta.isStrictMode, 'Strict mode errors should already be handled at compile time');
       throw new Error(`Attempted to resolve \`${name}\`, which was expected to be a modifier, but nothing was found.`);
     }
     then(constants.modifier(modifier, name));
@@ -146,7 +145,7 @@ function resolveComponentOrHelper(resolver, constants, meta, [, expr, {
   ifComponent,
   ifHelper
 }]) {
-  assert$1(isGetFreeComponentOrHelper(expr), 'Attempted to resolve a component or helper with incorrect opcode');
+  assert(isGetFreeComponentOrHelper(expr), 'Attempted to resolve a component or helper with incorrect opcode');
   let type = expr[0];
   if (type === SexpOpcodes.GetLexicalSymbol) {
     let {
@@ -161,6 +160,7 @@ function resolveComponentOrHelper(resolver, constants, meta, [, expr, {
     }
     let helper = constants.helper(definition, null, true);
     if (DEBUG && helper === null) {
+      assert(!meta.isStrictMode, 'Strict mode errors should already be handled at compile time');
       throw new Error(`Attempted to use a value as either a component or helper, but it did not have a component manager or helper manager associated with it. The value was: ${debugToString(definition)}`);
     }
     ifHelper(expect(helper, 'BUG: helper must exist'));
@@ -178,6 +178,7 @@ function resolveComponentOrHelper(resolver, constants, meta, [, expr, {
     } else {
       let helper = resolver.lookupHelper(name, owner);
       if (DEBUG && helper === null) {
+        assert(!meta.isStrictMode, 'Strict mode errors should already be handled at compile time');
         throw new Error(`Attempted to resolve \`${name}\`, which was expected to be a component or helper, but nothing was found.`);
       }
       ifHelper(constants.helper(helper, name));
@@ -185,24 +186,6 @@ function resolveComponentOrHelper(resolver, constants, meta, [, expr, {
   }
 }
 
-/**
- * <Foo @arg={{helper}}>
- */
-function resolveOptionalHelper(resolver, constants, meta, [, expr, {
-  ifHelper
-}]) {
-  assert$1(isGetFreeOptionalHelper(expr) || isGetFreeDeprecatedHelper(expr), 'Attempted to resolve a helper with incorrect opcode');
-  let {
-    upvars,
-    owner
-  } = assertResolverInvariants(meta);
-  let name = unwrap(upvars[expr[1]]);
-  let helper = resolver.lookupHelper(name, owner);
-  if (helper) {
-    ifHelper(constants.helper(helper, name), name, meta.moduleName);
-  }
-}
-
 /**
  * {{maybeHelperOrComponent}}
  */
@@ -211,7 +194,7 @@ function resolveOptionalComponentOrHelper(resolver, constants, meta, [, expr, {
   ifHelper,
   ifValue
 }]) {
-  assert$1(isGetFreeOptionalComponentOrHelper(expr), 'Attempted to resolve an optional component or helper with incorrect opcode');
+  assert(isGetFreeComponentOrHelper(expr), 'Attempted to resolve an optional component or helper with incorrect opcode');
   let type = expr[0];
   if (type === SexpOpcodes.GetLexicalSymbol) {
     let {
@@ -261,6 +244,8 @@ function lookupBuiltInHelper(expr, resolver, meta, constants, type) {
   let name = unwrap(upvars[expr[1]]);
   let helper = resolver.lookupBuiltInHelper(name);
   if (DEBUG && helper === null) {
+    assert(!meta.isStrictMode, 'Strict mode errors should already be handled at compile time');
+
     // Keyword helper did not exist, which means that we're attempting to use a
     // value of some kind that is not in scope
     throw new Error(`Attempted to resolve a ${type} in a strict mode template, but that value was not in scope: ${meta.upvars[expr[1]] ?? '{unknown variable}'}`);
@@ -272,10 +257,8 @@ const HighLevelResolutionOpcodes = {
   Modifier: 1003,
   Component: 1004,
   Helper: 1005,
-  OptionalHelper: 1006,
   ComponentOrHelper: 1007,
   OptionalComponentOrHelper: 1008,
-  Free: 1009,
   Local: 1010,
   TemplateLocal: 1011
 };
@@ -328,7 +311,7 @@ function stdlibOperand(value) {
   };
 }
 function nonSmallIntOperand(value) {
-  assert$1(!isSmallInt(value), 'Attempted to make a operand for an int that was not a small int, you should encode this as an immediate');
+  assert(!isSmallInt(value), 'Attempted to make a operand for an int that was not a small int, you should encode this as an immediate');
   return {
     type: HighLevelOperands.NonSmallInt,
     value
@@ -369,7 +352,7 @@ class Labels {
       target
     } of targets) {
       let address = labels[target] - at;
-      assert$1(heap.getbyaddr(at) === -1, 'Expected heap to contain a placeholder, but it did not');
+      assert(heap.getbyaddr(at) === -1, 'Expected heap to contain a placeholder, but it did not');
       heap.setbyaddr(at, address);
     }
   }
@@ -394,8 +377,6 @@ function encodeOp(encoder, constants, resolver, meta, op) {
         return resolveHelper(resolver, constants, meta, op);
       case HighLevelResolutionOpcodes.ComponentOrHelper:
         return resolveComponentOrHelper(resolver, constants, meta, op);
-      case HighLevelResolutionOpcodes.OptionalHelper:
-        return resolveOptionalHelper(resolver, constants, meta, op);
       case HighLevelResolutionOpcodes.OptionalComponentOrHelper:
         return resolveOptionalComponentOrHelper(resolver, constants, meta, op);
       case HighLevelResolutionOpcodes.Local:
@@ -409,17 +390,10 @@ function encodeOp(encoder, constants, resolver, meta, op) {
       case HighLevelResolutionOpcodes.TemplateLocal:
         {
           let [, valueIndex, then] = op;
-          let value = expect(meta.scopeValues, 'BUG: Attempted to gect a template local, but template does not have any')[valueIndex];
+          let value = expect(meta.scopeValues, 'BUG: Attempted to get a template local, but template does not have any')[valueIndex];
           then(constants.value(value));
           break;
         }
-      case HighLevelResolutionOpcodes.Free:
-        if (DEBUG) {
-          let [, upvarIndex] = op;
-          let freeName = expect(meta.upvars, 'BUG: attempted to resolve value but no upvars found')[upvarIndex];
-          throw new Error(`Attempted to resolve a value in a strict mode template, but that value was not in scope: ${freeName}`);
-        }
-        break;
       default:
         throw new Error(`Unexpected high level opcode ${op[0]}`);
     }
@@ -683,7 +657,7 @@ class Compilers {
     let name = sexp[0];
     let index = unwrap(this.names[name]);
     let func = this.funcs[index];
-    assert$1(!!func, `expected an implementation for ${sexp[0]}`);
+    assert(!!func, `expected an implementation for ${sexp[0]}`);
     func(op, sexp);
   }
 }
@@ -718,42 +692,17 @@ EXPRESSIONS.add(SexpOpcodes.GetLexicalSymbol, (op, [, sym, path]) => {
     withPath(op, path);
   });
 });
-EXPRESSIONS.add(SexpOpcodes.GetStrictKeyword, (op, [, sym, _path]) => {
-  op(HighLevelResolutionOpcodes.Free, sym, _handle => {
-    // TODO: Implement in strict mode
-  });
-});
-EXPRESSIONS.add(SexpOpcodes.GetFreeAsComponentOrHelperHeadOrThisFallback, () => {
-  // TODO: The logic for this opcode currently exists in STATEMENTS.Append, since
-  // we want different wrapping logic depending on if we are invoking a component,
-  // helper, or {{this}} fallback. Eventually we fix the opcodes so that we can
-  // traverse the subexpression tree like normal in this location.
-  throw new Error('unimplemented opcode');
-});
-EXPRESSIONS.add(SexpOpcodes.GetFreeAsHelperHeadOrThisFallback, (op, expr) => {
-  // <div id={{baz}}>
-
+EXPRESSIONS.add(SexpOpcodes.GetStrictKeyword, (op, expr) => {
   op(HighLevelResolutionOpcodes.Local, expr[1], _name => {
-    op(HighLevelResolutionOpcodes.OptionalHelper, expr, {
-      ifHelper: handle => {
-        Call(op, handle, null, null);
-      }
+    op(HighLevelResolutionOpcodes.Helper, expr, handle => {
+      Call(op, handle, null, null);
     });
   });
 });
-EXPRESSIONS.add(SexpOpcodes.GetFreeAsDeprecatedHelperHeadOrThisFallback, (op, expr) => {
-  // <Foo @bar={{baz}}>
-
+EXPRESSIONS.add(SexpOpcodes.GetFreeAsHelperHead, (op, expr) => {
   op(HighLevelResolutionOpcodes.Local, expr[1], _name => {
-    op(HighLevelResolutionOpcodes.OptionalHelper, expr, {
-      ifHelper: (handle, name, moduleName) => {
-        assert(expr[2] && expr[2].length === 1, '[BUG] Missing argument name');
-        let arg = expr[2][0];
-        deprecate(`The \`${name}\` helper was used in the \`${moduleName}\` template as \`${arg}={{${name}}}\`. ` + `This is ambigious between wanting the \`${arg}\` argument to be the \`${name}\` helper itself, ` + `or the result of invoking the \`${name}\` helper (current behavior). ` + `This implicit invocation behavior has been deprecated.\n\n` + `Instead, please explicitly invoke the helper with parenthesis, i.e. \`${arg}={{(${name})}}\`.\n\n` + `Note: the parenthesis are only required in this exact scenario where an ambiguity is present – where ` + `\`${name}\` referes to a global helper (as opposed to a local variable), AND ` + `the \`${name}\` helper invocation does not take any arguments, AND ` + `this occurs in a named argument position of a component invocation.\n\n` + `We expect this combination to be quite rare, as most helpers require at least one argument. ` + `There is no need to refactor helper invocations in cases where this deprecation was not triggered.`, false, {
-          id: 'argument-less-helper-paren-less-invocation'
-        });
-        Call(op, handle, null, null);
-      }
+    op(HighLevelResolutionOpcodes.Helper, expr, handle => {
+      Call(op, handle, null, null);
     });
   });
 });
@@ -1705,7 +1654,7 @@ STATEMENTS.add(SexpOpcodes.Append, (op, [, value]) => {
   // Special case for static values
   if (!Array.isArray(value)) {
     op(Op.Text, value === null || value === undefined ? '' : String(value));
-  } else if (isGetFreeOptionalComponentOrHelper(value)) {
+  } else if (isGetFreeComponentOrHelper(value)) {
     op(HighLevelResolutionOpcodes.OptionalComponentOrHelper, value, {
       ifComponent(component) {
         InvokeComponent(op, component, null, null, null, null);
@@ -1841,20 +1790,6 @@ STATEMENTS.add(SexpOpcodes.Each, (op, [, value, key, block, inverse]) => Replaya
     InvokeStaticBlock(op, inverse);
   }
 }));
-STATEMENTS.add(SexpOpcodes.With, (op, [, value, block, inverse]) => {
-  ReplayableIf(op, () => {
-    expr(op, value);
-    op(Op.Dup, $sp, 0);
-    op(Op.ToBoolean);
-    return 2;
-  }, () => {
-    InvokeStaticBlockWithStack(op, block, 1);
-  }, () => {
-    if (inverse) {
-      InvokeStaticBlock(op, inverse);
-    }
-  });
-});
 STATEMENTS.add(SexpOpcodes.Let, (op, [, positional, block]) => {
   let count = CompilePositional(op, positional);
   InvokeStaticBlockWithStack(op, block, count);