more passing tests

Author: ef4

packages/@ember/-internals/metal/lib/decorator.ts

@@ -120,11 +120,7 @@ export function makeComputedDecorator(
 ): ExtendedMethodDecorator {
   let decorator = function COMPUTED_DECORATOR(...args: unknown[]): DecoratorPropertyDescriptor {
     if (isModernDecoratorArgs(args)) {
-      return computedDecorator2023(
-        args,
-        desc,
-        DecoratorClass
-      ) as unknown as DecoratorPropertyDescriptor;
+      return computedDecorator2023(args, desc) as unknown as DecoratorPropertyDescriptor;
     }
 
     let [target, key, propertyDesc, maybeMeta, isClassicDecorator] = args as [
@@ -135,25 +131,7 @@ export function makeComputedDecorator(
       boolean | undefined
     ];
 
-    assert(
-      `Only one computed property decorator can be applied to a class field or accessor, but '${key}' was decorated twice. You may have added the decorator to both a getter and setter, which is unnecessary.`,
-      isClassicDecorator ||
-        !propertyDesc ||
-        !propertyDesc.get ||
-        !COMPUTED_GETTERS.has(propertyDesc.get)
-    );
-
-    let meta = arguments.length === 3 ? metaFor(target) : maybeMeta;
-    desc.setup(target, key, propertyDesc, meta!);
-
-    let computedDesc: PropertyDescriptor = {
-      enumerable: desc.enumerable,
-      configurable: desc.configurable,
-      get: DESCRIPTOR_GETTER_FUNCTION(key, desc),
-      set: DESCRIPTOR_SETTER_FUNCTION(key, desc),
-    };
-
-    return computedDesc;
+    return makeDescriptor(desc, target, key, propertyDesc, maybeMeta, isClassicDecorator);
   };
 
   setClassicDecorator(decorator, desc);
@@ -163,14 +141,49 @@ export function makeComputedDecorator(
   return decorator;
 }
 
-function computedDecorator2023(
-  args: Paramters<Decorator>,
+function makeDescriptor(
   desc: ComputedDescriptor,
-  DecoratorClass: { prototype: object }
-) {
-  let dec = identifyModernDecoratorArgs(args);
-  console.log(`ignoring modern decorator on ${dec.kind} ${dec.context.name?.toString()}`);
-  return;
+  target: object,
+  key: string,
+  propertyDesc?: DecoratorPropertyDescriptor,
+  maybeMeta?: Meta,
+  isClassicDecorator?: boolean
+): PropertyDescriptor {
+  assert(
+    `Only one computed property decorator can be applied to a class field or accessor, but '${key}' was decorated twice. You may have added the decorator to both a getter and setter, which is unnecessary.`,
+    isClassicDecorator ||
+      !propertyDesc ||
+      !propertyDesc.get ||
+      !COMPUTED_GETTERS.has(propertyDesc.get)
+  );
+
+  let meta = arguments.length === 3 ? metaFor(target) : maybeMeta;
+  desc.setup(target, key, propertyDesc, meta!);
+
+  let computedDesc: PropertyDescriptor = {
+    enumerable: desc.enumerable,
+    configurable: desc.configurable,
+    get: DESCRIPTOR_GETTER_FUNCTION(key, desc),
+    set: DESCRIPTOR_SETTER_FUNCTION(key, desc),
+  };
+  return computedDesc;
+}
+
+function computedDecorator2023(args: Parameters<Decorator>, desc: ComputedDescriptor) {
+  const dec = identifyModernDecoratorArgs(args);
+  switch (dec.kind) {
+    case 'field':
+      dec.context.addInitializer(function (this: any) {
+        Object.defineProperty(
+          this,
+          dec.context.name,
+          makeDescriptor(desc, this, dec.context.name as string)
+        );
+      });
+      return;
+    default:
+      console.log(`unimplemented: injected on ${dec.kind} ${dec.context.name?.toString()}`);
+  }
 }
 
 /////////////

packages/@ember/-internals/metal/lib/injected_property.ts

@@ -5,6 +5,11 @@ import { computed } from './computed';
 import type { DecoratorPropertyDescriptor, ElementDescriptor } from './decorator';
 import { isElementDescriptor } from './decorator';
 import { defineProperty } from './properties';
+import {
+  type Decorator,
+  identifyModernDecoratorArgs,
+  isModernDecoratorArgs,
+} from './decorator-util';
 
 export let DEBUG_INJECTION_FUNCTIONS: WeakMap<Function, any>;
 
@@ -49,6 +54,10 @@ function inject(
   let elementDescriptor;
   let name: string | undefined;
 
+  if (isModernDecoratorArgs(args)) {
+    return inject2023(type, undefined, args);
+  }
+
   if (isElementDescriptor(args)) {
     elementDescriptor = args;
   } else if (typeof args[0] === 'string') {
@@ -88,4 +97,40 @@ function inject(
   }
 }
 
+function inject2023(type: string, name: string | undefined, args: Parameters<Decorator>) {
+  const dec = identifyModernDecoratorArgs(args);
+  switch (dec.kind) {
+    case 'field':
+      dec.context.addInitializer(function (this: any) {
+        let getInjection = function (this: any) {
+          let owner = getOwner(this) || this.container; // fallback to `container` for backwards compat
+
+          assert(
+            `Attempting to lookup an injected property on an object without a container, ensure that the object was instantiated via a container.`,
+            Boolean(owner)
+          );
+
+          return owner.lookup(`${type}:${name || (dec.context.name as string)}`);
+        };
+
+        if (DEBUG) {
+          DEBUG_INJECTION_FUNCTIONS.set(getInjection, {
+            type,
+            name,
+          });
+        }
+
+        Object.defineProperty(this, dec.context.name, {
+          get: getInjection,
+          set(value) {
+            defineProperty(this, dec.context.name as string, null, value);
+          },
+        });
+      });
+      return;
+    default:
+      throw new Error(`unimplemented: injected on ${dec.kind} ${dec.context.name?.toString()}`);
+  }
+}
+
 export default inject;

packages/@ember/object/index.ts

@@ -11,6 +11,11 @@ import { setObservers } from '@ember/-internals/utils';
 import type { AnyFn } from '@ember/-internals/utility-types';
 import CoreObject from '@ember/object/core';
 import Observable from '@ember/object/observable';
+import {
+  type Decorator,
+  identifyModernDecoratorArgs,
+  isModernDecoratorArgs,
+} from '@ember/-internals/metal/lib/decorator-util';
 
 export {
   notifyPropertyChange,
@@ -181,6 +186,10 @@ export function action(desc: PropertyDescriptor): ExtendedMethodDecorator;
 export function action(
   ...args: ElementDescriptor | [PropertyDescriptor]
 ): PropertyDescriptor | ExtendedMethodDecorator {
+  if (isModernDecoratorArgs(args)) {
+    return action2023(args) as unknown as PropertyDescriptor;
+  }
+
   let actionFn: object | Function;
 
   if (!isElementDescriptor(args)) {
@@ -309,3 +318,20 @@ export function observer<T extends AnyFn>(
   });
   return func;
 }
+
+function action2023(args: Parameters<Decorator>) {
+  const dec = identifyModernDecoratorArgs(args);
+  switch (dec.kind) {
+    case 'method':
+      dec.context.addInitializer(function (this: any) {
+        Object.defineProperty(
+          this,
+          dec.context.name,
+          setupAction(this, dec.context.name, dec.value)
+        );
+      });
+      break;
+    default:
+      throw new Error(`unimplemented: action on ${dec.kind} ${dec.context.name?.toString()}`);
+  }
+}

packages/@ember/service/tests/service_test.js

@@ -50,7 +50,6 @@ moduleFor(
       let owner = buildOwner();
 
       class MainService extends Service {}
-
       class Foo extends EmberObject {
         @inject main;
       }