Deprecate the computed macros (RFC 1234)

packages/@ember/-internals/deprecations/index.ts

@@ -168,6 +168,13 @@ export const DEPRECATIONS = {
     until: '8.0.0',
     url: 'https://deprecations.emberjs.com/id/deprecate-ember-utils',
   }),
+  DEPRECATE_COMPUTED_MACROS: deprecation({
+    id: 'deprecate-computed-macros',
+    for: 'ember-source',
+    since: { available: '7.5.0' },
+    until: '9.0.0',
+    url: 'https://deprecations.emberjs.com/id/deprecate-computed-macros',
+  }),
 };
 
 export function deprecateUntil(message: string, deprecation: DeprecationObject) {

packages/@ember/-internals/glimmer/lib/components/link-to.ts

@@ -328,7 +328,7 @@ class _LinkTo extends InternalComponent {
 
     // consume the current router state so we invalidate when QP changes
     // TODO: can we narrow this down to QP changes only?
-    consumeTag(tagFor(routing, 'currentState'));
+    consumeTag(tagFor(routing.router, 'currentState'));
 
     if (DEBUG) {
       try {
@@ -417,7 +417,7 @@ class _LinkTo extends InternalComponent {
 
   // GH #17963
   private currentRouteCache = createCache<Maybe<string>>(() => {
-    consumeTag(tagFor(this.routing, 'currentState'));
+    consumeTag(tagFor(this.routing.router, 'currentState'));
     return untrack(() => this.routing.currentRouteName);
   });
 

packages/@ember/-internals/glimmer/tests/integration/components/curly-components-test.js

@@ -6,7 +6,10 @@ import {
   equalsElement,
   runTask,
   defineSimpleModifier,
+  expectDeprecation,
+  testUnless,
 } from 'internal-test-helpers';
+import { DEPRECATIONS } from '@ember/-internals/deprecations';
 
 import { tracked } from '@ember/-internals/metal';
 import { alias } from '@ember/object/computed';
@@ -1571,7 +1574,12 @@ moduleFor(
       this.assertText('3');
     }
 
-    ['@test ensure aliases are watched properly [GH#17243]']() {
+    [`${testUnless(DEPRECATIONS.DEPRECATE_COMPUTED_MACROS.isRemoved)} @test ensure aliases are watched properly [GH#17243]`]() {
+      expectDeprecation(
+        /from `@ember\/object\/computed` is deprecated/,
+        DEPRECATIONS.DEPRECATE_COMPUTED_MACROS.isEnabled
+      );
+
       let fooInstance, barInstance;
 
       let FooComponent = class extends GlimmerComponent {

packages/@ember/-internals/glimmer/tests/integration/content-test.js

@@ -640,7 +640,12 @@ class DynamicContentTest extends RenderingTestCase {
     this.assertInvariants();
   }
 
-  ['@test it can render a readOnly property of a path']() {
+  [`${testUnless(DEPRECATIONS.DEPRECATE_COMPUTED_MACROS.isRemoved)} @test it can render a readOnly property of a path`]() {
+    expectDeprecation(
+      /from `@ember\/object\/computed` is deprecated/,
+      DEPRECATIONS.DEPRECATE_COMPUTED_MACROS.isEnabled
+    );
+
     let Messenger = class extends EmberObject {
       @readOnly('a.b.c')
       message;

packages/@ember/-internals/runtime/tests/system/array_proxy/length_test.js

@@ -1,6 +1,6 @@
 import ArrayProxy from '@ember/array/proxy';
-import EmberObject, { observer } from '@ember/object';
-import { oneWay as reads, not } from '@ember/object/computed';
+import EmberObject, { computed, observer } from '@ember/object';
+import { oneWay as reads } from '@ember/object/computed';
 import { A as a } from '@ember/array';
 import {
   moduleFor,
@@ -39,8 +39,10 @@ moduleFor(
       assert
     ) {
       let proxy = class extends ArrayProxy {
-        @not('length')
-        isEmpty;
+        @computed('length')
+        get isEmpty() {
+          return !this.length;
+        }
       }.create({
         content: a([1, 2, 3]),
       });
@@ -186,6 +188,11 @@ moduleFor(
     async [`${testUnless(DEPRECATIONS.DEPRECATE_ARRAY_PROXY.isRemoved)} @test array proxy + aliasedProperty complex test`](
       assert
     ) {
+      expectDeprecation(
+        /from `@ember\/object\/computed` is deprecated/,
+        DEPRECATIONS.DEPRECATE_COMPUTED_MACROS.isEnabled
+      );
+
       let aCalled, bCalled, cCalled, dCalled, eCalled;
 
       aCalled = bCalled = cCalled = dCalled = eCalled = 0;

packages/@ember/object/computed.ts

@@ -1,6 +1,21 @@
 export { ComputedProperty as default } from '@ember/-internals/metal/lib/computed';
 export { default as expandProperties } from '@ember/-internals/metal/lib/expand_properties';
-export { default as alias } from '@ember/-internals/metal/lib/alias';
+
+import { assert } from '@ember/debug';
+import internalAlias, { type AliasDecorator } from '@ember/-internals/metal/lib/alias';
+import { isDecoratorCall } from '@ember/-internals/metal/lib/decorator';
+import { deprecateComputedMacro } from './lib/computed/computed_macros';
+
+export function alias(altKey: string): AliasDecorator {
+  assert(
+    'You attempted to use @alias as a decorator directly, but it requires a `altKey` parameter',
+    !isDecoratorCall(Array.prototype.slice.call(arguments))
+  );
+
+  deprecateComputedMacro('alias');
+
+  return internalAlias(altKey);
+}
 
 export {
   empty,

packages/@ember/object/lib/computed/computed_macros.ts

@@ -15,6 +15,13 @@ import { DEPRECATIONS, deprecateUntil } from '@ember/-internals/deprecations';
 @module @ember/object
 */
 
+export function deprecateComputedMacro(name: string) {
+  deprecateUntil(
+    `\`${name}\` from \`@ember/object/computed\` is deprecated. Use a getter instead.`,
+    DEPRECATIONS.DEPRECATE_COMPUTED_MACROS
+  );
+}
+
 function expandPropertiesToArray(predicateName: string, properties: string[]) {
   let expandedProperties: string[] = [];
 
@@ -43,6 +50,8 @@ function generateComputedWithPredicate(name: string, predicate: (value: unknown)
       !isDecoratorCall(properties)
     );
 
+    deprecateComputedMacro(name);
+
     let dependentKeys = expandPropertiesToArray(name, properties);
 
     let computedFunc = computed(...dependentKeys, function () {
@@ -250,13 +259,16 @@ export function none(dependentKey: string) {
   @return {ComputedProperty} computed property which returns inverse of the
   original value for property
   @public
+  @deprecated Use a getter instead.
 */
 export function not(dependentKey: string) {
   assert(
     'You attempted to use @not as a decorator directly, but it requires a `dependentKey` parameter',
     !isDecoratorCall(Array.prototype.slice.call(arguments))
   );
 
+  deprecateComputedMacro('not');
+
   return computed(dependentKey, function () {
     return !get(this, dependentKey);
   });
@@ -298,13 +310,16 @@ export function not(dependentKey: string) {
   @return {ComputedProperty} computed property which converts to boolean the
   original value for property
   @public
+  @deprecated Use a getter instead.
 */
 export function bool(dependentKey: string) {
   assert(
     'You attempted to use @bool as a decorator directly, but it requires a `dependentKey` parameter',
     !isDecoratorCall(Array.prototype.slice.call(arguments))
   );
 
+  deprecateComputedMacro('bool');
+
   return computed(dependentKey, function () {
     return Boolean(get(this, dependentKey));
   });
@@ -344,13 +359,16 @@ export function bool(dependentKey: string) {
   @return {ComputedProperty} computed property which match the original value
   for property against a given RegExp
   @public
+  @deprecated Use a getter instead.
 */
 export function match(dependentKey: string, regexp: RegExp) {
   assert(
     'You attempted to use @match as a decorator directly, but it requires `dependentKey` and `regexp` parameters',
     !isDecoratorCall(Array.prototype.slice.call(arguments))
   );
 
+  deprecateComputedMacro('match');
+
   return computed(dependentKey, function () {
     let value = get(this, dependentKey);
     return regexp.test(value);
@@ -390,13 +408,16 @@ export function match(dependentKey: string, regexp: RegExp) {
   @return {ComputedProperty} computed property which returns true if the
   original value for property is equal to the given value.
   @public
+  @deprecated Use a getter instead.
 */
 export function equal(dependentKey: string, value: unknown) {
   assert(
     'You attempted to use @equal as a decorator directly, but it requires `dependentKey` and `value` parameter',
     !isDecoratorCall(Array.prototype.slice.call(arguments))
   );
 
+  deprecateComputedMacro('equal');
+
   return computed(dependentKey, function () {
     return get(this, dependentKey) === value;
   });
@@ -435,13 +456,16 @@ export function equal(dependentKey: string, value: unknown) {
   @return {ComputedProperty} computed property which returns true if the
   original value for property is greater than given value.
   @public
+  @deprecated Use a getter instead.
 */
 export function gt(dependentKey: string, value: number) {
   assert(
     'You attempted to use @gt as a decorator directly, but it requires `dependentKey` and `value` parameters',
     !isDecoratorCall(Array.prototype.slice.call(arguments))
   );
 
+  deprecateComputedMacro('gt');
+
   return computed(dependentKey, function () {
     return get(this, dependentKey) > value;
   });
@@ -480,13 +504,16 @@ export function gt(dependentKey: string, value: number) {
   @return {ComputedProperty} computed property which returns true if the
   original value for property is greater or equal then given value.
   @public
+  @deprecated Use a getter instead.
 */
 export function gte(dependentKey: string, value: number) {
   assert(
     'You attempted to use @gte as a decorator directly, but it requires `dependentKey` and `value` parameters',
     !isDecoratorCall(Array.prototype.slice.call(arguments))
   );
 
+  deprecateComputedMacro('gte');
+
   return computed(dependentKey, function () {
     return get(this, dependentKey) >= value;
   });
@@ -525,13 +552,16 @@ export function gte(dependentKey: string, value: number) {
   @return {ComputedProperty} computed property which returns true if the
   original value for property is less then given value.
   @public
+  @deprecated Use a getter instead.
 */
 export function lt(dependentKey: string, value: number) {
   assert(
     'You attempted to use @lt as a decorator directly, but it requires `dependentKey` and `value` parameters',
     !isDecoratorCall(Array.prototype.slice.call(arguments))
   );
 
+  deprecateComputedMacro('lt');
+
   return computed(dependentKey, function () {
     return get(this, dependentKey) < value;
   });
@@ -570,13 +600,16 @@ export function lt(dependentKey: string, value: number) {
   @return {ComputedProperty} computed property which returns true if the
   original value for property is less or equal than given value.
   @public
+  @deprecated Use a getter instead.
 */
 export function lte(dependentKey: string, value: number) {
   assert(
     'You attempted to use @lte as a decorator directly, but it requires `dependentKey` and `value` parameters',
     !isDecoratorCall(Array.prototype.slice.call(arguments))
   );
 
+  deprecateComputedMacro('lte');
+
   return computed(dependentKey, function () {
     return get(this, dependentKey) <= value;
   });
@@ -625,6 +658,7 @@ export function lte(dependentKey: string, value: number) {
   @return {ComputedProperty} computed property which performs a logical `and` on
   the values of all the original values for properties.
   @public
+  @deprecated Use a getter instead.
 */
 export const and = generateComputedWithPredicate('and', (value) => value);
 
@@ -668,6 +702,7 @@ export const and = generateComputedWithPredicate('and', (value) => value);
   @return {ComputedProperty} computed property which performs a logical `or` on
   the values of all the original values for properties.
   @public
+  @deprecated Use a getter instead.
 */
 export const or = generateComputedWithPredicate('or', (value) => !value);
 
@@ -704,6 +739,7 @@ export const or = generateComputedWithPredicate('or', (value) => !value);
   @return {ComputedProperty} computed property which creates an alias to the
   original value for property.
   @public
+  @deprecated Use a getter instead.
 */
 
 /**
@@ -744,13 +780,16 @@ export const or = generateComputedWithPredicate('or', (value) => !value);
   @return {ComputedProperty} computed property which creates a one way computed
   property to the original value for property.
   @public
+  @deprecated Use a getter instead.
 */
 export function oneWay(dependentKey: string) {
   assert(
     'You attempted to use @oneWay as a decorator directly, but it requires a `dependentKey` parameter',
     !isDecoratorCall(Array.prototype.slice.call(arguments))
   );
 
+  deprecateComputedMacro('oneWay');
+
   return alias(dependentKey).oneWay() as FieldDecorator;
 }
 
@@ -808,13 +847,16 @@ export function oneWay(dependentKey: string) {
   property to the original value for property.
   @since 1.5.0
   @public
+  @deprecated Use a getter instead.
 */
 export function readOnly(dependentKey: string) {
   assert(
     'You attempted to use @readOnly as a decorator directly, but it requires a `dependentKey` parameter',
     !isDecoratorCall(Array.prototype.slice.call(arguments))
   );
 
+  deprecateComputedMacro('readOnly');
+
   return alias(dependentKey).readOnly() as FieldDecorator;
 }
 
@@ -852,13 +894,16 @@ export function readOnly(dependentKey: string) {
   deprecation to the original value for property.
   @since 1.7.0
   @public
+  @deprecated Use a getter instead.
 */
 export function deprecatingAlias(dependentKey: string, options: DeprecationOptions) {
   assert(
     'You attempted to use @deprecatingAlias as a decorator directly, but it requires `dependentKey` and `options` parameters',
     !isDecoratorCall(Array.prototype.slice.call(arguments))
   );
 
+  deprecateComputedMacro('deprecatingAlias');
+
   return computed(dependentKey, {
     get(key) {
       deprecate(