chrome-devtools-frontend 1.0.1473514 → 1.0.1506453

package/scripts/devtools_build.mjs

@@ -6,7 +6,6 @@ import childProcess from 'node:child_process';
 import fs from 'node:fs/promises';
 import path from 'node:path';
 import {performance} from 'node:perf_hooks';
-import util from 'node:util';
 
 import {
   autoninjaPyPath,
@@ -16,7 +15,65 @@ import {
   vpython3ExecutablePath,
 } from './devtools_paths.js';
 
-const execFile = util.promisify(childProcess.execFile);
+/**
+ * Errors returned from `spawn()` will have additional `stderr` and `stdout`
+ * properties, similar to what we'd get from `child_process.execFile()`.
+ */
+class SpawnError extends Error {
+  /**
+   * Constructor for errors generated from `spawn()`.
+   *
+   * @param {string} message The actual error message.
+   * @param {string} stderr The child process' error output.
+   * @param {string} stdout The child process' regular output.
+   */
+  constructor(message, stderr, stdout) {
+    super(message);
+    this.stderr = stderr;
+    this.stdout = stdout;
+  }
+}
+
+/**
+ * Promisified wrapper around `child_process.spawn()`.
+ *
+ * In addition to forwarding the `options` to `child_process.spawn()`, it'll also
+ * set the `shell` option to `true`, to ensure that on Windows we can correctly
+ * invoke `.bat` files (necessary for the Python3 wrapper script).
+ *
+ * @param {string} command The command to run.
+ * @param {Array<string>} args List of string arguments to pass to the `command`.
+ * @param {Object} options Passed directly to `child_process.spawn()`.
+ * @returns {Promise<{stdout: string, stderr: string}>}
+ */
+function spawn(command, args, options = {}) {
+  return new Promise((resolve, reject) => {
+    const child = childProcess.spawn(command, args, {...options, shell: true});
+
+    let stdout = '';
+    let stderr = '';
+
+    child.stdout.on('data', data => {
+      stdout += data.toString();
+    });
+
+    child.stderr.on('data', data => {
+      stderr += data.toString();
+    });
+
+    child.on('exit', (code, signal) => {
+      if (signal) {
+        reject(new SpawnError(`Process terminated due to signal ${signal}`, stderr, stdout));
+      } else if (code) {
+        reject(new SpawnError(`Process exited with code ${code}`, stderr, stdout));
+      } else {
+        resolve({stdout, stderr});
+      }
+    });
+
+    child.on('error', reject);
+  });
+}
 
 /**
  * Representation of the feature set that is configured for Chrome. This
@@ -33,7 +90,7 @@ export class FeatureSet {
   /**
    * Disables the given `feature`.
    *
-   * @param {string} feature the name of the feature to disable.
+   * @param feature the name of the feature to disable.
    */
   disable(feature) {
     this.#disabled.add(feature);
@@ -48,8 +105,8 @@ export class FeatureSet {
    * ```
    * The parameters are additive.
    *
-   * @param {string} feature the name of the feature to enable.
-   * @param {object} parameters the additional parameters to pass to it, in
+   * @param feature the name of the feature to enable.
+   * @param parameters the additional parameters to pass to it, in
    *                            the form of key/value pairs.
    */
   enable(feature, parameters = {}) {
@@ -132,10 +189,10 @@ export class FeatureSet {
 /**
  * Constructs a human readable error message for the given build `error`.
  *
- * @param {Error} error the `Error` from the failed `autoninja` invocation.
- * @param {string} outDir the absolute path to the `target` out directory.
- * @param {string} target the targe relative to `//out`.
- * @return {string} the human readable error message.
+ * @param error the `Error` from the failed `autoninja` invocation.
+ * @param outDir the absolute path to the `target` out directory.
+ * @param target the target relative to `//out`.
+ * @returns the human readable error message.
  */
 function buildErrorMessageForNinja(error, outDir, target) {
   const {message, stderr, stdout} = error;
@@ -177,6 +234,7 @@ ${output}
   return `Failed to build \`${target}' in \`${outDir}' (${message.substring(0, message.indexOf('\n'))})`;
 }
 
+/** @enum */
 export const BuildStep = {
   GN: 'gn',
   AUTONINJA: 'autoninja',
@@ -186,11 +244,11 @@ export class BuildError extends Error {
   /**
    * Constructs a new `BuildError` with the given parameters.
    *
-   * @param {keyof BuildStep} step the build step that failed.
-   * @param {Object} options additional options for the `BuildError`.
-   * @param {Error} options.cause the actual cause for the build error.
-   * @param {string} options.outDir the absolute path to the `target` out directory.
-   * @param {string} options.target the target relative to `//out`.
+   * @param step the build step that failed.
+   * @param {object} options additional options for the `BuildError`.
+   * @param options.cause the actual cause for the build error.
+   * @param options.outDir the absolute path to the `target` out directory.
+   * @param options.target the target relative to `//out`.
    */
   constructor(step, options) {
     const {cause, outDir, target} = options;
@@ -211,8 +269,8 @@ export class BuildError extends Error {
  */
 
 /**
- * @param {string} target
- * @return {Promise<void>}
+ * @param target the target relative to `//out`.
+ * @returns the GN args for the `target`.
  */
 export async function prepareBuild(target) {
   const outDir = path.join(rootPath(), 'out', target);
@@ -224,11 +282,13 @@ export async function prepareBuild(target) {
     try {
       const gnExe = vpython3ExecutablePath();
       const gnArgs = [gnPyPath(), '-q', 'gen', outDir];
-      await execFile(gnExe, gnArgs);
+      await spawn(gnExe, gnArgs);
     } catch (cause) {
       throw new BuildError(BuildStep.GN, {cause, outDir, target});
     }
   }
+
+  return await gnArgsForTarget(target);
 }
 
 /** @type Map<string, Promise<Map<string, string>>> */
@@ -243,7 +303,7 @@ function gnArgsForTarget(target) {
         const cwd = rootPath();
         const gnExe = vpython3ExecutablePath();
         const gnArgs = [gnPyPath(), '-q', 'args', outDir, '--json', '--list', '--short'];
-        const {stdout} = await execFile(gnExe, gnArgs, {cwd});
+        const {stdout} = await spawn(gnExe, gnArgs, {cwd});
         return new Map(JSON.parse(stdout).map(arg => [arg.name, arg.current?.value ?? arg.default?.value]));
       } catch {
         return new Map();
@@ -270,7 +330,7 @@ function gnRefsForTarget(target, filename) {
       const outDir = path.join(rootPath(), 'out', target);
       const gnExe = vpython3ExecutablePath();
       const gnArgs = [gnPyPath(), 'refs', outDir, '--as=output', filename];
-      const {stdout} = await execFile(gnExe, gnArgs, {cwd});
+      const {stdout} = await spawn(gnExe, gnArgs, {cwd});
       return stdout.trim().split('\n');
     })();
     gnRefsPerTarget.set(filename, gnRef);
@@ -279,15 +339,22 @@ function gnRefsForTarget(target, filename) {
 }
 
 async function computeBuildTargetsForFiles(target, filenames) {
-  if (filenames && filenames.length && filenames.every(filename => path.extname(filename) === '.css')) {
+  const SUPPORTED_EXTENSIONS = ['.css', '.ts'];
+  if (filenames && filenames.length &&
+      filenames.every(filename => SUPPORTED_EXTENSIONS.includes(path.extname(filename)))) {
     if (isInChromiumDirectory().isInChromium) {
       filenames = filenames.map(filename => path.join('third_party', 'devtools-frontend', 'src', filename));
     }
     const gnArgs = await gnArgsForTarget(target);
-    if (gnArgs.get('is_debug') === 'true') {
+    if (gnArgs.get('devtools_bundle') === 'false') {
       try {
         const gnRefs = (await Promise.all(filenames.map(filename => gnRefsForTarget(target, filename)))).flat();
         if (gnRefs.length) {
+          // If there are any changes to TypeScript files, we need to also rebuild the
+          // `en-US.json`, as otherwise the changes to `UIStrings` aren't picked up.
+          if (filenames.some(filename => path.extname(filename) === '.ts')) {
+            gnRefs.push('collect_strings');
+          }
           return gnRefs;
         }
       } catch (error) {
@@ -299,10 +366,10 @@ async function computeBuildTargetsForFiles(target, filenames) {
 }
 
 /**
- * @param {string} target
- * @param {AbortSignal=} signal
- * @param {Array<string>=} filenames
- * @return {Promise<BuildResult>} a `BuildResult` with statistics for the build.
+ * @param target
+ * @param signal
+ * @param filenames
+ * @returns a `BuildResult` with statistics for the build.
  */
 export async function build(target, signal, filenames) {
   const startTime = performance.now();
@@ -315,7 +382,7 @@ export async function build(target, signal, filenames) {
   try {
     const autoninjaExe = vpython3ExecutablePath();
     const autoninjaArgs = [autoninjaPyPath(), '-C', outDir, ...buildTargets];
-    await execFile(autoninjaExe, autoninjaArgs, {signal});
+    await spawn(autoninjaExe, autoninjaArgs, {shell: true, signal});
   } catch (cause) {
     if (cause.name === 'AbortError') {
       throw cause;

package/scripts/devtools_build.test.mjs

@@ -6,9 +6,9 @@
 //
 //   npx mocha scripts/devtools_build.test.mjs
 
-import { assert } from 'chai';
+import {assert} from 'chai';
 
-import { BuildError, BuildStep, FeatureSet } from './devtools_build.mjs';
+import {BuildError, BuildStep, FeatureSet} from './devtools_build.mjs';
 
 describe('FeatureSet', () => {
   it('yields an empty set of arguments by default', () => {
@@ -24,15 +24,15 @@ describe('FeatureSet', () => {
     featureSet.enable('DevToolsWellKnown');
 
     assert.deepEqual(
-      [...featureSet],
-      ['--enable-features=DevToolsFreestyler,DevToolsWellKnown'],
+        [...featureSet],
+        ['--enable-features=DevToolsFreestyler,DevToolsWellKnown'],
     );
   });
 
   it('can enable features with parameters', () => {
     const featureSet = new FeatureSet();
 
-    featureSet.enable('DevToolsFreestyler', { patching: true });
+    featureSet.enable('DevToolsFreestyler', {patching: true});
     featureSet.enable('DevToolsFreestyler', {
       user_tier: 'TESTERS',
       multimodal: true,
@@ -42,10 +42,10 @@ describe('FeatureSet', () => {
     });
 
     assert.deepEqual(
-      [...featureSet],
-      [
-        '--enable-features=DevToolsAiAssistancePerformanceAgent:insights_enabled/true,DevToolsFreestyler:multimodal/true/patching/true/user_tier/TESTERS',
-      ],
+        [...featureSet],
+        [
+          '--enable-features=DevToolsAiAssistancePerformanceAgent:insights_enabled/true,DevToolsFreestyler:multimodal/true/patching/true/user_tier/TESTERS',
+        ],
     );
   });
 
@@ -56,8 +56,8 @@ describe('FeatureSet', () => {
     featureSet.disable('DevToolsAiGeneratedTimelineLabels');
 
     assert.deepEqual(
-      [...featureSet],
-      ['--disable-features=DevToolsAiGeneratedTimelineLabels,MediaRouter'],
+        [...featureSet],
+        ['--disable-features=DevToolsAiGeneratedTimelineLabels,MediaRouter'],
     );
   });
 
@@ -65,79 +65,79 @@ describe('FeatureSet', () => {
     const featureSet = new FeatureSet();
 
     featureSet.disable('MediaRouter');
-    featureSet.enable('DevToolsAutomaticFileSystems');
+    featureSet.enable('DevToolsWellKnown');
 
     assert.deepEqual(
-      [...featureSet],
-      [
-        '--disable-features=MediaRouter',
-        '--enable-features=DevToolsAutomaticFileSystems',
-      ],
+        [...featureSet],
+        [
+          '--disable-features=MediaRouter',
+          '--enable-features=DevToolsWellKnown',
+        ],
     );
   });
 
   it('can disable previously enabled features', () => {
     const featureSet = new FeatureSet();
 
-    featureSet.enable('DevToolsFreestyler', { patching: true });
+    featureSet.enable('DevToolsFreestyler', {patching: true});
     featureSet.enable('DevToolsWellKnown');
     featureSet.disable('DevToolsFreestyler');
 
     assert.deepEqual(
-      [...featureSet],
-      [
-        '--disable-features=DevToolsFreestyler',
-        '--enable-features=DevToolsWellKnown',
-      ],
+        [...featureSet],
+        [
+          '--disable-features=DevToolsFreestyler',
+          '--enable-features=DevToolsWellKnown',
+        ],
     );
   });
 
   it('can merge feature sets', () => {
     const fs1 = new FeatureSet();
-    fs1.enable('DevToolsFreestyler', { patching: true });
+    fs1.enable('DevToolsFreestyler', {patching: true});
     fs1.enable('DevToolsWellKnown');
     fs1.disable('MediaRouter');
     const fs2 = new FeatureSet();
     fs2.disable('DevToolsWellKnown');
-    fs2.enable('DevToolsFreestyler', { multimodal: true });
+    fs2.enable('DevToolsFreestyler', {multimodal: true});
 
     fs1.merge(fs2);
 
     assert.deepEqual(
-      [...fs1],
-      [
-        '--disable-features=DevToolsWellKnown,MediaRouter',
-        '--enable-features=DevToolsFreestyler:multimodal/true/patching/true',
-      ],
+        [...fs1],
+        [
+          '--disable-features=DevToolsWellKnown,MediaRouter',
+          '--enable-features=DevToolsFreestyler:multimodal/true/patching/true',
+        ],
     );
     assert.deepEqual(
-      [...fs2],
-      [
-        '--disable-features=DevToolsWellKnown',
-        '--enable-features=DevToolsFreestyler:multimodal/true',
-      ],
+        [...fs2],
+        [
+          '--disable-features=DevToolsWellKnown',
+          '--enable-features=DevToolsFreestyler:multimodal/true',
+        ],
     );
   });
 
   it('can parse --enable-features/--disable-features declarations', () => {
     assert.deepEqual(FeatureSet.parse('MediaRouter'), [
-      { feature: 'MediaRouter', parameters: {} },
+      {feature: 'MediaRouter', parameters: {}},
     ]);
     assert.deepEqual(
-      FeatureSet.parse('DevToolsFreestyler:multimodal/true/patching/true'),
-      [
-        {
-          feature: 'DevToolsFreestyler',
-          parameters: { multimodal: 'true', patching: 'true' },
-        },
-      ],
+        FeatureSet.parse('DevToolsFreestyler:multimodal/true/patching/true'),
+        [
+          {
+            feature: 'DevToolsFreestyler',
+            parameters: {multimodal: 'true', patching: 'true'},
+          },
+        ],
     );
     assert.deepEqual(
-      FeatureSet.parse('DevToolsFreestyler:multimodal/true,DevToolsWellKnown'),
-      [
-        { feature: 'DevToolsFreestyler', parameters: { multimodal: 'true' } },
-        { feature: 'DevToolsWellKnown', parameters: {} },
-      ],
+        FeatureSet.parse('DevToolsFreestyler:multimodal/true,DevToolsWellKnown'),
+        [
+          {feature: 'DevToolsFreestyler', parameters: {multimodal: 'true'}},
+          {feature: 'DevToolsWellKnown', parameters: {}},
+        ],
     );
   });
 

package/scripts/devtools_paths.py

@@ -123,10 +123,5 @@ def package_json_path():
     return path.join(devtools_root_path(), 'package.json')
 
 
-def browser_protocol_path():
-    return path.join(third_party_path(), 'blink', 'public',
-                     'devtools_protocol', 'browser_protocol.pdl')
-
-
 def custom_devtools_frontend_path(target):
     return path.join(root_path(), 'out', target, 'gen', 'front_end')

package/scripts/eslint_rules/README.md

@@ -15,8 +15,8 @@ all rules that disallow something with `no-`.
 
 ## Testing the rules
 
-When writing a custom ESLint rule, place the logic into a file `lib/foo.js` and
-add a corresponding test for the logic to `tests/foo.test.js`.
+When writing a custom ESLint rule, place the logic into a file `lib/foo.ts` and
+add a corresponding test for the logic to `tests/foo.test.ts`.
 
 You can use
 
@@ -25,3 +25,5 @@ npm run test -- ./scripts/eslint_rules/tests
 ```
 
 to run the tests for the custom ESLint rules.
+
+To run only specific test cases, add `only: true` to the objects within the valid/invalid arrays.

package/scripts/eslint_rules/lib/canvas-context-tracking.ts

@@ -82,7 +82,7 @@ export default createRule({
 
     /**
      * Updates the counter for the current scope.
-     * @param {'save'|'restore'} methodName
+     * @param methodName
      **/
     function trackContextCall(methodName: CanvasCall): void {
       const currentScopeNode = stack.at(-1);

package/scripts/eslint_rules/lib/check-css-import.ts

@@ -3,7 +3,7 @@
 // found in the LICENSE file.
 
 /**
- * @fileoverview Prevent usage of customElements.define() and use the helper
+ * @file Prevent usage of customElements.define() and use the helper
  * function instead
  */
 
@@ -28,7 +28,7 @@ export default createRule({
   },
   defaultOptions: [],
   create: function(context) {
-    const filename = context.getFilename();
+    const filename = context.filename;
     return {
       ImportDeclaration(node) {
         const importPath = path.normalize(`${node.source.value}`);

package/scripts/eslint_rules/lib/check-license-header.ts

@@ -21,7 +21,7 @@ const FRONT_END_FOLDER = path.join(
 
 const CURRENT_YEAR = `${new Date().getFullYear()}`;
 const LINE_LICENSE_HEADER = [
-  `Copyright ${CURRENT_YEAR} The Chromium Authors. All rights reserved.`,
+  `Copyright ${CURRENT_YEAR} The Chromium Authors`,
   'Use of this source code is governed by a BSD-style license that can be',
   'found in the LICENSE file.',
 ];
@@ -149,8 +149,8 @@ export default createRule({
   },
   defaultOptions: [],
   create: function(context) {
-    const sourceCode = context.sourceCode ?? context.getSourceCode();
-    const filename = context.filename ?? context.getFilename();
+    const sourceCode = context.sourceCode;
+    const filename = context.filename;
     const fileName = filename;
     // Fix windows paths for exemptions
     const relativePath = path.relative(FRONT_END_FOLDER, fileName).replace(/\\/g, '/');

package/scripts/eslint_rules/lib/check-test-definitions.ts

@@ -41,14 +41,14 @@ export default createRule({
   },
   defaultOptions: [],
   create: function(context) {
-    const sourceCode = context.sourceCode ?? context.getSourceCode();
+    const sourceCode = context.sourceCode;
     return {
       MemberExpression(node) {
         if (node.object.type !== 'Identifier' || node.property.type !== 'Identifier') {
           return;
         }
 
-        if ((node.object.name === 'it' || node.object.name === 'describe' || node.object.name === 'itScreenshot') &&
+        if ((node.object.name === 'it' || node.object.name === 'describe') &&
             (node.property.name === 'skip' || node.property.name === 'skipOnPlatforms') &&
             node.parent?.type === 'CallExpression') {
           const testNameNode = node.property.name === 'skip' ? node.parent.arguments[0] : node.parent.arguments[1];

package/scripts/eslint_rules/lib/enforce-custom-element-definitions-location.ts

@@ -35,7 +35,7 @@ export default createRule<[{rootFrontendDirectory: string}], 'definitionInWrongF
   },
   defaultOptions: [{rootFrontendDirectory: ''}],
   create: function(context) {
-    const filename = context.filename ?? context.getFilename();
+    const filename = context.filename;
     const classDefiningFileName = path.resolve(filename);
 
     let frontEndDirectory = '';

package/scripts/eslint_rules/lib/enforce-optional-properties-last.ts

@@ -3,7 +3,7 @@
 // found in the LICENSE file.
 
 /**
- * @fileoverview Rule to enforce that within TypeScript Types, optional properties should come last.
+ * @file Rule to enforce that within TypeScript Types, optional properties should come last.
  * This is to avoid a bug where clang-format will incorrectly indent a type that's failing this.
  * @author Paul Irish
  */

package/scripts/eslint_rules/lib/enforce-ui-strings-as-const.ts

@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 /**
- * @fileoverview Rule to check ES import usage
+ * @file Rule to check ES import usage
  * @author Ergün Erdoğmuş
  */
 

package/scripts/eslint_rules/lib/es-modules-import.ts

@@ -3,7 +3,7 @@
 // found in the LICENSE file.
 
 /**
- * @fileoverview Rule to check ES import usage
+ * @file Rule to check ES import usage
  * @author Tim van der Lippe
  */
 
@@ -349,7 +349,8 @@ export default createRule<[], MessageIds>({
                   ['testing', 'test_setup.ts'].join(path.sep),
                   ) &&
               importPath.includes([path.sep, 'testing', path.sep].join(''))) {
-            /** Within test files we allow the direct import of test helpers.
+            /**
+             * Within test files we allow the direct import of test helpers.
              * The entry point detection detects test_setup.ts as an
              * entrypoint, but we don't treat it as such, it's just a file
              * that Karma runs to setup the environment.

package/scripts/eslint_rules/lib/html-tagged-template.ts

@@ -25,7 +25,7 @@ export default createRule({
   },
   defaultOptions: [],
   create: function(context) {
-    const sourceCode = context.sourceCode ?? context.getSourceCode();
+    const sourceCode = context.sourceCode;
     let lastImport: ImportDeclaration|null = null;
     let shorthandDefined = false;
     return {
@@ -33,7 +33,7 @@ export default createRule({
         lastImport = node;
       },
       VariableDeclarator(node) {
-        const scope = sourceCode.getScope ? sourceCode.getScope(node) : context.getScope();
+        const scope = sourceCode.getScope(node);
         if (scope.type !== 'module') {
           return;
         }

package/scripts/eslint_rules/lib/inject-checkbox-styles.ts

@@ -9,6 +9,7 @@ import {createRule} from './utils/ruleCreator.ts';
 
 type AssignmentExpression = TSESTree.AssignmentExpression;
 type TemplateElement = TSESTree.TemplateElement;
+type Node = TSESTree.Node;
 
 // Define MessageIds used in the rule
 type MessageIds =|'missingCheckboxStylesImport'|'missingCheckboxStylesAdoption';
@@ -40,7 +41,7 @@ export default createRule<[], MessageIds>({
       missingCheckboxStylesImport:
           'When rendering a checkbox, ensure the common checkbox styles are imported from components/input/input.ts.',
       missingCheckboxStylesAdoption:
-          'When rendering a checkbox, ensure the common checkbox styles are adopted into the component shadow root.',
+          'When rendering a checkbox, ensure the common checkbox styles are adopted into the component shadow root or included in the template.',
     },
     schema: []
   },
@@ -53,6 +54,7 @@ export default createRule<[], MessageIds>({
     let adoptedStyleSheetsCallNode: AssignmentExpression|null = null;
     // Use a more specific type for the set elements if possible, otherwise Node or TemplateElement
     const litCheckboxElements = new Set<TemplateElement>();
+    let hasCheckboxStylesInTemplate = false;
     return {
       TaggedTemplateExpression(node) {
         // Assuming isLitHtmlTemplateCall is typed appropriately in utils.ts
@@ -68,6 +70,9 @@ export default createRule<[], MessageIds>({
           // We store the node so we can use it as the basis for the ESLint error later.
           litCheckboxElements.add(quasiNode);
         }
+        if (node.quasi.expressions.some(isCheckboxStylesReference)) {
+          hasCheckboxStylesInTemplate = true;
+        }
       },
 
       ImportDeclaration(node) {
@@ -121,6 +126,10 @@ export default createRule<[], MessageIds>({
           return;
         }
 
+        if (hasCheckboxStylesInTemplate) {
+          return;
+        }
+
         if (!adoptedStyleSheetsCallNode) {
           for (const checkbox of litCheckboxElements) {
             context.report({
@@ -139,29 +148,8 @@ export default createRule<[], MessageIds>({
           return;
         }
 
-        const inputCheckboxStylesAdoptionReference = adoptedStyleSheetsCallNode.right.elements.find(elem => {
-          // Ensure elem is not null and is a MemberExpression before accessing properties
-          if (!elem || elem.type !== 'MemberExpression') {
-            return false;
-          }
-
-          // Ensure object and property are Identifiers before accessing name
-          if (elem.object.type !== 'Identifier' || elem.property.type !== 'Identifier') {
-            return false;
-          }
-
-          // Check that if we imported the styles as `Input`, that the reference here matches.
-          // Use non-null assertion for inputStylesImportedName as it's checked by foundInputStylesImport logic
-          if (elem.object.name !== inputStylesImportedName) {
-            return false;
-          }
-
-          if (elem.property.name !== 'checkboxStyles') {
-            return false;
-          }
-
-          return true;
-        });
+        const inputCheckboxStylesAdoptionReference =
+            adoptedStyleSheetsCallNode.right.elements.find(isCheckboxStylesReference);
 
         if (!inputCheckboxStylesAdoptionReference) {
           context.report({
@@ -171,5 +159,29 @@ export default createRule<[], MessageIds>({
         }
       }
     };
+
+    function isCheckboxStylesReference(elem: Node|null): boolean {
+      // Ensure elem is not null and is a MemberExpression before accessing properties
+      if (!elem || elem.type !== 'MemberExpression') {
+        return false;
+      }
+
+      // Ensure object and property are Identifiers before accessing name
+      if (elem.object.type !== 'Identifier' || elem.property.type !== 'Identifier') {
+        return false;
+      }
+
+      // Check that if we imported the styles as `Input`, that the reference here matches.
+      // Use non-null assertion for inputStylesImportedName as it's checked by foundInputStylesImport logic
+      if (elem.object.name !== inputStylesImportedName) {
+        return false;
+      }
+
+      if (elem.property.name !== 'checkboxStyles') {
+        return false;
+      }
+
+      return true;
+    }
   }
 });