@mui/internal-code-infra 0.1.1-canary.5 → 0.1.1-canary.7

package/build/eslint/mui/rules/no-constructor-assigned-field.d.mts

@@ -0,0 +1,50 @@
+import { ESLintUtils } from '@typescript-eslint/utils';
+export type PropertyDefinition = import('@typescript-eslint/utils').TSESTree.PropertyDefinition;
+export type Node = import('@typescript-eslint/utils').TSESTree.Node;
+/**
+ * ESLint rule that disallows assigning a class field in the constructor when it is also
+ * declared as a (non-`declare`) class field.
+ *
+ * Babel 8 only strips TypeScript fields marked `declare` (see mui/material-ui#49241), so a
+ * field without an initializer is emitted as a property definition that sets it to
+ * `undefined` before the constructor assigns it again. Either initialize the field at its
+ * declaration, or mark it `declare` so it only serves as a type annotation.
+ *
+ * `declare` fields are exempt from TypeScript's strict property initialization check
+ * (TS2564), so prefer initializing at the declaration where the value doesn't depend on
+ * constructor arguments. The `declare` suggestion is only offered when every path through the
+ * constructor assigns the field, i.e. for an unconditional top-level assignment.
+ *
+ * Only plain `=` assignments count: compound assignments read the field rather than
+ * re-initialize it. A field with an initializer is only reported for an unconditional
+ * top-level assignment, as a conditional one overrides a default. Private (`#`) and decorated
+ * fields are ignored: they are runtime declarations that `declare` can't replace.
+ *
+ * @example
+ * // Invalid
+ * class ModalManager {
+ *   private modals: Modal[];
+ *   constructor() {
+ *     this.modals = [];
+ *   }
+ * }
+ *
+ * @example
+ * // Valid - initialized at the declaration
+ * class ModalManager {
+ *   private modals: Modal[] = [];
+ * }
+ *
+ * @example
+ * // Valid - declared only, assigned in the constructor
+ * class ModalManager {
+ *   declare private modals: Modal[];
+ *   constructor(modals: Modal[]) {
+ *     this.modals = modals;
+ *   }
+ * }
+ */
+declare const _default: ESLintUtils.RuleModule<"addDeclare" | "assignedInConstructor", [], unknown, ESLintUtils.RuleListener> & {
+    name: string;
+};
+export default _default;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mui/internal-code-infra",
-  "version": "0.1.1-canary.5",
+  "version": "0.1.1-canary.7",
   "author": "MUI Team",
   "description": "Infra scripts and configs to be used across MUI repos.",
   "license": "MIT",
@@ -53,7 +53,7 @@
     "code-infra": "./bin/code-infra.mjs"
   },
   "dependencies": {
-    "@argos-ci/core": "6.8.5",
+    "@argos-ci/core": "6.8.6",
     "@babel/cli": "^8.0.6",
     "@babel/core": "^8.0.6",
     "@babel/plugin-syntax-jsx": "^8.0.1",
@@ -104,7 +104,7 @@
     "eslint-plugin-testing-library": "^7.16.2",
     "execa": "^10.0.1",
     "git-url-parse": "^16.1.0",
-    "globals": "^17.12.0",
+    "globals": "^17.13.0",
     "globby": "^16.2.4",
     "html-validate": "^11.16.1",
     "minimatch": "^10.2.6",
@@ -187,7 +187,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitSha": "c2a0ca83b8dd00ae2fa2b5714dbc6684d50926d9",
+  "gitSha": "d15ad292b4ac08fbfbb55aebffb354f659d71aea",
   "scripts": {
     "build": "tsc -p tsconfig.build.json",
     "typescript": "tsc -noEmit",

package/src/eslint/mui/config.mjs

@@ -1,5 +1,5 @@
 import { defineConfig } from 'eslint/config';
-import { EXTENSION_DTS } from '../extensions.mjs';
+import { EXTENSION_DTS, EXTENSION_TS_ONLY } from '../extensions.mjs';
 
 const restrictedMethods = ['setTimeout', 'setInterval', 'clearTimeout', 'clearInterval'];
 
@@ -538,6 +538,13 @@ export function createCoreConfig(options = {}) {
         '@typescript-eslint/return-await': 'off',
       },
     },
+    {
+      name: 'mui-base/ts',
+      files: [`**/*${EXTENSION_TS_ONLY}`],
+      rules: {
+        'mui/no-constructor-assigned-field': 'error',
+      },
+    },
     {
       name: 'mui-base/dts',
       files: [`**/*${EXTENSION_DTS}`],

package/src/eslint/mui/index.mjs

@@ -14,6 +14,7 @@ import addUndefToOptional from './rules/add-undef-to-optional.mjs';
 import flattenParentheses from './rules/flatten-parentheses.mjs';
 import noPresentationRole from './rules/no-presentation-role.mjs';
 import noFloatingCleanup from './rules/no-floating-cleanup.mjs';
+import noConstructorAssignedField from './rules/no-constructor-assigned-field.mjs';
 
 /** @type {import('eslint').ESLint.Plugin} */
 const muiPlugin = {
@@ -39,6 +40,7 @@ const muiPlugin = {
     'flatten-parentheses': /** @type {any} */ (flattenParentheses),
     'no-presentation-role': noPresentationRole,
     'no-floating-cleanup': /** @type {any} */ (noFloatingCleanup),
+    'no-constructor-assigned-field': /** @type {any} */ (noConstructorAssignedField),
   },
 };
 

package/src/eslint/mui/rules/no-constructor-assigned-field.mjs

@@ -0,0 +1,183 @@
+import { ASTUtils, ESLintUtils } from '@typescript-eslint/utils';
+
+/**
+ * @typedef {import('@typescript-eslint/utils').TSESTree.PropertyDefinition} PropertyDefinition
+ * @typedef {import('@typescript-eslint/utils').TSESTree.Node} Node
+ */
+
+const createRule = ESLintUtils.RuleCreator(
+  (name) =>
+    `https://github.com/mui/mui-public/blob/master/packages/code-infra/src/eslint/mui/rules/${name}.mjs`,
+);
+
+/**
+ * Returns the constructor whose own code contains `node`, or `null` when `node` is outside a
+ * constructor or inside a nested function or class.
+ * @param {Node} node
+ */
+function getEnclosingConstructor(node) {
+  let current = node.parent;
+  while (current && !ASTUtils.isFunction(current)) {
+    if (current.type === 'ClassBody') {
+      return null;
+    }
+    current = current.parent;
+  }
+  const method = current?.parent;
+  return method && ASTUtils.isConstructor(method) ? method : null;
+}
+
+/**
+ * Returns the extra edits needed before `field` can be marked `declare`.
+ * @param {PropertyDefinition} field
+ */
+function getDeclareHint(field) {
+  const edits = [];
+  if (field.value) {
+    edits.push('drop its initializer');
+  }
+  if (field.definite) {
+    edits.push('drop the `!`');
+  }
+  if (field.override) {
+    edits.push('drop `override`');
+  }
+  return edits.length > 0 ? ` (${edits.join(', ')})` : '';
+}
+
+/**
+ * ESLint rule that disallows assigning a class field in the constructor when it is also
+ * declared as a (non-`declare`) class field.
+ *
+ * Babel 8 only strips TypeScript fields marked `declare` (see mui/material-ui#49241), so a
+ * field without an initializer is emitted as a property definition that sets it to
+ * `undefined` before the constructor assigns it again. Either initialize the field at its
+ * declaration, or mark it `declare` so it only serves as a type annotation.
+ *
+ * `declare` fields are exempt from TypeScript's strict property initialization check
+ * (TS2564), so prefer initializing at the declaration where the value doesn't depend on
+ * constructor arguments. The `declare` suggestion is only offered when every path through the
+ * constructor assigns the field, i.e. for an unconditional top-level assignment.
+ *
+ * Only plain `=` assignments count: compound assignments read the field rather than
+ * re-initialize it. A field with an initializer is only reported for an unconditional
+ * top-level assignment, as a conditional one overrides a default. Private (`#`) and decorated
+ * fields are ignored: they are runtime declarations that `declare` can't replace.
+ *
+ * @example
+ * // Invalid
+ * class ModalManager {
+ *   private modals: Modal[];
+ *   constructor() {
+ *     this.modals = [];
+ *   }
+ * }
+ *
+ * @example
+ * // Valid - initialized at the declaration
+ * class ModalManager {
+ *   private modals: Modal[] = [];
+ * }
+ *
+ * @example
+ * // Valid - declared only, assigned in the constructor
+ * class ModalManager {
+ *   declare private modals: Modal[];
+ *   constructor(modals: Modal[]) {
+ *     this.modals = modals;
+ *   }
+ * }
+ */
+export default createRule({
+  name: 'no-constructor-assigned-field',
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description:
+        'Disallow assigning class fields in the constructor when they are also declared as class fields',
+    },
+    hasSuggestions: true,
+    messages: {
+      assignedInConstructor:
+        "Field '{{name}}' is declared as a class field and also assigned in the constructor. " +
+        'Either initialize it at the declaration and remove the constructor assignment, ' +
+        'or mark it `declare`{{declareHint}}.',
+      addDeclare: 'Mark the field `declare`.',
+    },
+    schema: [],
+  },
+  defaultOptions: [],
+  create(context) {
+    /**
+     * Fields assigned in a constructor, mapped to whether any of those assignments is an
+     * unconditional top-level statement.
+     * @type {Map<PropertyDefinition, boolean>}
+     */
+    const assignedFields = new Map();
+
+    return {
+      AssignmentExpression(node) {
+        if (
+          node.operator !== '=' ||
+          node.left.type !== 'MemberExpression' ||
+          node.left.object.type !== 'ThisExpression'
+        ) {
+          return;
+        }
+        const name = ASTUtils.getPropertyName(node.left);
+        if (name === null) {
+          return;
+        }
+        const constructor = getEnclosingConstructor(node);
+        if (!constructor) {
+          return;
+        }
+
+        const field = constructor.parent.body.find(
+          /** @returns {member is PropertyDefinition} */
+          (member) =>
+            member.type === 'PropertyDefinition' &&
+            !member.static &&
+            !member.declare &&
+            member.decorators.length === 0 &&
+            ASTUtils.getPropertyName(member) === name,
+        );
+        if (!field) {
+          return;
+        }
+
+        const statement = node.parent;
+        const unconditional =
+          statement.type === 'ExpressionStatement' && statement.parent === constructor.value.body;
+        assignedFields.set(field, Boolean(assignedFields.get(field)) || unconditional);
+      },
+      'ClassBody:exit'(classBody) {
+        for (const member of classBody.body) {
+          if (member.type !== 'PropertyDefinition' || !assignedFields.has(member)) {
+            continue;
+          }
+          const unconditional = Boolean(assignedFields.get(member));
+          if (member.value && !unconditional) {
+            continue;
+          }
+
+          const declareHint = getDeclareHint(member);
+          context.report({
+            node: member,
+            messageId: 'assignedInConstructor',
+            data: { name: ASTUtils.getPropertyName(member), declareHint },
+            suggest:
+              unconditional && declareHint === ''
+                ? [
+                    {
+                      messageId: 'addDeclare',
+                      fix: (fixer) => fixer.insertTextBefore(member, 'declare '),
+                    },
+                  ]
+                : [],
+          });
+        }
+      },
+    };
+  },
+});

package/src/eslint/testConfig.mjs

@@ -63,6 +63,7 @@ export function createTestConfig() {
         'import/named': 'off',
         'mui/disallow-active-element-as-key-event-target': 'error',
         'mui/consistent-production-guard': 'off',
+        'mui/no-constructor-assigned-field': 'off',
 
         // disable eslint-plugin-jsx-a11y
         // tests are not driven by assistive technology