chrome-devtools-frontend 1.0.946920 → 1.0.948445

package/front_end/ui/legacy/components/source_frame/SourceFrame.ts

@@ -112,8 +112,9 @@ export class SourceFrameImpl extends Common.ObjectWrapper.eventMixin<EventTypes,
   private shouldAutoPrettyPrint: boolean;
   private readonly progressToolbarItem: UI.Toolbar.ToolbarItem;
   private textEditorInternal: TextEditor.TextEditor.TextEditor;
-  private prettyBaseDoc: CodeMirror.Text|null = null;
+  // The 'clean' document, before editing
   private baseDoc: CodeMirror.Text;
+  private prettyBaseDoc: CodeMirror.Text|null = null;
   private displayedSelection: CodeMirror.EditorSelection|null = null;
   private searchConfig: UI.SearchableView.SearchConfig|null;
   private delayedFindSearchMatches: (() => void)|null;
@@ -212,27 +213,7 @@ export class SourceFrameImpl extends Common.ObjectWrapper.eventMixin<EventTypes,
       TextEditor.Config.allowScrollPastEof.instance(),
       TextEditor.Config.codeFolding.instance(),
       TextEditor.Config.autoDetectIndent.instance(),
-      CodeMirror.EditorView.theme({
-        '&.cm-editor': {height: '100%'},
-        '.cm-scroller': {overflow: 'auto'},
-        '.cm-lineNumbers .cm-gutterElement.cm-nonBreakableLine': {color: 'var(--color-non-breakable-line)'},
-        '.cm-searchMatch': {
-          border: '1px solid var(--color-search-match-border)',
-          borderRadius: '3px',
-          margin: '0 -1px',
-          '&.cm-searchMatch-selected': {
-            borderRadius: '1px',
-            backgroundColor: 'var(--color-selected-search-match-background)',
-            borderColor: 'var(--color-selected-search-match-background)',
-            '&, & *': {
-              color: 'var(--color-selected-search-match) !important',
-            },
-          },
-        },
-        ':host-context(.pretty-printed) & .cm-lineNumbers .cm-gutterElement': {
-          color: 'var(--legacy-accent-color)',
-        },
-      }),
+      sourceFrameTheme,
       CodeMirror.EditorView.domEventHandlers({
         focus: () => this.onFocus(),
         blur: () => this.onBlur(),
@@ -352,6 +333,9 @@ export class SourceFrameImpl extends Common.ObjectWrapper.eventMixin<EventTypes,
     this.updatePrettyPrintState();
   }
 
+  // If this is a disassembled WASM file or a pretty-printed file,
+  // wire in a line number formatter that shows binary offsets or line
+  // numbers in the original source.
   private getLineNumberFormatter(): CodeMirror.Extension {
     if (this.options.lineNumbers === false) {
       return [];
@@ -1099,18 +1083,20 @@ const searchHighlighter = CodeMirror.ViewPlugin.fromClass(class {
     const {doc} = view.state;
     for (const {from, to} of view.visibleRanges) {
       let pos = from;
-      for (const line of doc.iterLines(doc.lineAt(from).number, doc.lineAt(to).number + 1)) {
-        active.regexp.lastIndex = 0;
-        for (;;) {
-          const match = active.regexp.exec(line);
-          if (!match) {
-            break;
+      for (const part of doc.iterRange(from, to)) {
+        if (part !== '\n') {
+          active.regexp.lastIndex = 0;
+          for (;;) {
+            const match = active.regexp.exec(part);
+            if (!match) {
+              break;
+            }
+            const start = pos + match.index, end = start + match[0].length;
+            const current = active.currentRange && active.currentRange.from === start && active.currentRange.to === end;
+            builder.add(start, end, current ? currentSearchMatchDeco : searchMatchDeco);
           }
-          const start = pos + match.index, end = start + match[0].length;
-          const current = active.currentRange && active.currentRange.from === start && active.currentRange.to === end;
-          builder.add(start, end, current ? currentSearchMatchDeco : searchMatchDeco);
         }
-        pos += line.length + 1;
+        pos += part.length;
       }
     }
     return builder.finish();
@@ -1163,3 +1149,25 @@ function markNonBreakableLines(disassembly: Common.WasmDisassembly.WasmDisassemb
     return CodeMirror.RangeSet.of(marks);
   });
 }
+
+const sourceFrameTheme = CodeMirror.EditorView.theme({
+  '&.cm-editor': {height: '100%'},
+  '.cm-scroller': {overflow: 'auto'},
+  '.cm-lineNumbers .cm-gutterElement.cm-nonBreakableLine': {color: 'var(--color-non-breakable-line)'},
+  '.cm-searchMatch': {
+    border: '1px solid var(--color-search-match-border)',
+    borderRadius: '3px',
+    margin: '0 -1px',
+    '&.cm-searchMatch-selected': {
+      borderRadius: '1px',
+      backgroundColor: 'var(--color-selected-search-match-background)',
+      borderColor: 'var(--color-selected-search-match-background)',
+      '&, & *': {
+        color: 'var(--color-selected-search-match) !important',
+      },
+    },
+  },
+  ':host-context(.pretty-printed) & .cm-lineNumbers .cm-gutterElement': {
+    color: 'var(--legacy-accent-color)',
+  },
+});

package/front_end/ui/legacy/themeColors.css

@@ -110,7 +110,7 @@
   --color-image-preview-background: rgb(255 255 255);
 
   /* Colors for styling inputs */
-  --color-input-outline: rgb(128 134 139);
+  --color-input-outline: rgb(218 220 224);
   --color-input-outline-active: rgb(26 115 232);
   --color-input-outline-error: rgb(217 48 37);
   --color-input-outline-disabled: rgba(128 134 139 / 20%);

package/front_end/ui/legacy/utils/append-style.ts

@@ -2,19 +2,8 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-import * as Root from '../../../core/root/root.js';
-
-export function appendStyle(node: Node, cssReference: string|{cssContent: string}): void {
-  let content: string;
-  if (typeof cssReference === 'string') {
-    content = Root.Runtime.cachedResources.get(cssReference) || '';
-    if (!content) {
-      console.error(cssReference + ' not preloaded. Check module.json');
-    }
-  } else {
-    content = cssReference.cssContent;
-  }
+export function appendStyle(node: Node, {cssContent}: {cssContent: string}): void {
   const styleElement = document.createElement('style');
-  styleElement.textContent = content;
+  styleElement.textContent = cssContent;
   node.appendChild(styleElement);
 }

package/front_end/ui/legacy/utils/create-shadow-root-with-core-styles.ts

@@ -7,7 +7,7 @@ import {focusChanged} from './focus-changed.js';
 import {injectCoreStyles} from './inject-core-styles.js';
 
 interface Options {
-  cssFile?: string|CSSStyleSheet[]|{cssContent: string};
+  cssFile?: CSSStyleSheet[]|{cssContent: string};
   delegatesFocus?: boolean;
 }
 
@@ -22,10 +22,12 @@ export function createShadowRootWithCoreStyles(element: Element, options: Option
 
   const shadowRoot = element.attachShadow({mode: 'open', delegatesFocus});
   injectCoreStyles(shadowRoot);
-  if (typeof cssFile === 'string' || (cssFile !== undefined && 'cssContent' in cssFile)) {
-    appendStyle(shadowRoot, cssFile);
-  } else if (cssFile) {
-    shadowRoot.adoptedStyleSheets = cssFile;
+  if (cssFile) {
+    if ('cssContent' in cssFile) {
+      appendStyle(shadowRoot, cssFile);
+    } else {
+      shadowRoot.adoptedStyleSheets = cssFile;
+    }
   }
   shadowRoot.addEventListener('focus', focusChanged, true);
   return shadowRoot;

package/package.json

@@ -27,10 +27,8 @@
     "auto-unittest": "scripts/test/run_auto_unittests.py --no-text-coverage",
     "build": "autoninja -C out/Default",
     "build-release": "autoninja -C out/Release",
-    "check": "npm run check-json && npm run check-gn && npm run check-lint && npm run check-loc",
+    "check": "npm run check-lint && npm run check-loc",
     "check-external-links": "third_party/node/node.py --output scripts/check_external_links.js",
-    "check-gn": "third_party/node/node.py --output scripts/check_gn.js",
-    "check-json": "third_party/node/node.py --output scripts/json_validator/validate_module_json.js",
     "check-lint": "third_party/node/node.py --output scripts/test/run_lint_check_js.mjs && third_party/node/node.py --output scripts/test/run_lint_check_css.js",
     "check-lint-css": "third_party/node/node.py --output scripts/test/run_lint_check_css.js",
     "collect-strings": "third_party/node/node.py --output third_party/i18n/collect-strings.js front_end",
@@ -55,5 +53,5 @@
     "unittest": "scripts/test/run_unittests.py --no-text-coverage",
     "watch": "third_party/node/node.py --output scripts/watch_build.js"
   },
-  "version": "1.0.946920"
+  "version": "1.0.948445"
 }

package/scripts/build/build_inspector_overlay.py

@@ -12,7 +12,6 @@ Builds inspector overlay:
 
 from os import path
 from os.path import join
-from modular_build import read_file, write_file
 from itertools import tee
 
 import os
@@ -29,6 +28,21 @@ finally:
     sys.path = original_sys_path
 
 
+def read_file(filename):
+    with open(path.normpath(filename), 'rt', encoding='utf-8') as input:
+        return input.read()
+
+
+def write_file(filename, content):
+    if path.exists(filename):
+        os.remove(filename)
+    directory = path.dirname(filename)
+    if not path.exists(directory):
+        os.makedirs(directory)
+    with open(filename, 'wt', encoding='utf-8') as output:
+        output.write(content)
+
+
 def check_size(filename, data, max_size):
     assert len(
         data

package/scripts/build/rjsmin.py

@@ -119,8 +119,7 @@ def _make_jsmin(python_only=False):
     charclass = r'(?:\[[^\\\]\r\n]*(?:\\[^\r\n][^\\\]\r\n]*)*\])'
     nospecial = r'[^/\\\[\r\n]'
     regex = r'(?:/(?![\r\n/*])%s*(?:(?:\\[^\r\n]|%s)%s*)*/)' % (
-        nospecial, charclass, nospecial
-    )
+        nospecial, charclass, nospecial)
     space = r'(?:%s|%s)' % (space_chars, space_comment)
     newline = r'(?:%s?[\r\n])' % line_comment
 
@@ -147,36 +146,28 @@ def _make_jsmin(python_only=False):
                     first = last = char
             if last is not None:
                 result.append((first, last))
-            return ''.join(['%s%s%s' % (
-                chr(first),
-                last > first + 1 and '-' or '',
-                last != first and chr(last) or ''
-            ) for first, last in result])  # noqa
+            return ''.join([
+                '%s%s%s' % (chr(first), last > first + 1 and '-'
+                            or '', last != first and chr(last) or '')
+                for first, last in result
+            ])  # noqa
 
         return _re.sub(
             r'([\000-\040\047])',  # \047 for better portability
-            lambda m: '\\%03o' % ord(m.group(1)), (
-                sequentize(result)
-                .replace('\\', '\\\\')
-                .replace('[', '\\[')
-                .replace(']', '\\]')
-            )
-        )
+            lambda m: '\\%03o' % ord(m.group(1)),
+            (sequentize(result).replace('\\', '\\\\').replace(
+                '[', '\\[').replace(']', '\\]')))
 
     def id_literal_(what):
         """ Make id_literal like char class """
         match = _re.compile(what).match
-        result = ''.join([
-            chr(c) for c in xrange(127) if not match(chr(c))
-        ])
+        result = ''.join([chr(c) for c in xrange(127) if not match(chr(c))])
         return '[^%s]' % fix_charclass(result)
 
     def not_id_literal_(keep):
         """ Make negated id_literal like char class """
         match = _re.compile(id_literal_(keep)).match
-        result = ''.join([
-            chr(c) for c in xrange(127) if not match(chr(c))
-        ])
+        result = ''.join([chr(c) for c in xrange(127) if not match(chr(c))])
         return r'[%s]' % fix_charclass(result)
 
     not_id_literal = not_id_literal_(r'[a-zA-Z0-9_$]')
@@ -192,28 +183,26 @@ def _make_jsmin(python_only=False):
 
     space_sub_simple = _re.compile((
         # noqa pylint: disable = bad-continuation
-
-        r'(%(dull)s+)'                                         # 0
-        r'|(%(strings)s%(dull)s*)'                             # 1
+        r'(%(dull)s+)'  # 0
+        r'|(%(strings)s%(dull)s*)'  # 1
         r'|(?<=%(preregex1)s)'
-            r'%(space)s*(?:%(newline)s%(space)s*)*'
-            r'(%(regex)s)'                                     # 2
-            r'(%(space)s*(?:%(newline)s%(space)s*)+'           # 3
-                r'(?=%(post_regex_off)s))?'
+        r'%(space)s*(?:%(newline)s%(space)s*)*'
+        r'(%(regex)s)'  # 2
+        r'(%(space)s*(?:%(newline)s%(space)s*)+'  # 3
+        r'(?=%(post_regex_off)s))?'
         r'|(?<=%(preregex2)s)'
-            r'%(space)s*(?:(%(newline)s)%(space)s*)*'          # 4
-            r'(%(regex)s)'                                     # 5
-            r'(%(space)s*(?:%(newline)s%(space)s*)+'           # 6
-                r'(?=%(post_regex_off)s))?'
+        r'%(space)s*(?:(%(newline)s)%(space)s*)*'  # 4
+        r'(%(regex)s)'  # 5
+        r'(%(space)s*(?:%(newline)s%(space)s*)+'  # 6
+        r'(?=%(post_regex_off)s))?'
         r'|(?<=%(id_literal_close)s)'
-            r'%(space)s*(?:(%(newline)s)%(space)s*)+'          # 7
-            r'(?=%(id_literal_open)s)'
+        r'%(space)s*(?:(%(newline)s)%(space)s*)+'  # 7
+        r'(?=%(id_literal_open)s)'
         r'|(?<=%(id_literal)s)(%(space)s)+(?=%(id_literal)s)'  # 8
-        r'|(?<=\+)(%(space)s)+(?=\+)'                          # 9
-        r'|(?<=-)(%(space)s)+(?=-)'                            # 10
+        r'|(?<=\+)(%(space)s)+(?=\+)'  # 9
+        r'|(?<=-)(%(space)s)+(?=-)'  # 10
         r'|%(space)s+'
-        r'|(?:%(newline)s%(space)s*)+'
-    ) % locals()).sub
+        r'|(?:%(newline)s%(space)s*)+') % locals()).sub
 
     # print space_sub_simple.__self__.pattern
 
@@ -245,35 +234,33 @@ def _make_jsmin(python_only=False):
 
     space_sub_banged = _re.compile((
         # noqa pylint: disable = bad-continuation
-
-        r'(%(dull)s+)'                                         # 0
-        r'|(%(strings)s%(dull)s*)'                             # 1
+        r'(%(dull)s+)'  # 0
+        r'|(%(strings)s%(dull)s*)'  # 1
         r'|(?<=%(preregex1)s)'
-            r'(%(space)s*(?:%(newline)s%(space)s*)*)'          # 2
-            r'(%(regex)s)'                                     # 3
-            r'(%(space)s*(?:%(newline)s%(space)s*)+'           # 4
-                r'(?=%(post_regex_off)s))?'
+        r'(%(space)s*(?:%(newline)s%(space)s*)*)'  # 2
+        r'(%(regex)s)'  # 3
+        r'(%(space)s*(?:%(newline)s%(space)s*)+'  # 4
+        r'(?=%(post_regex_off)s))?'
         r'|(?<=%(preregex2)s)'
-            r'(%(space)s*(?:(%(newline)s)%(space)s*)*)'        # 5, 6
-            r'(%(regex)s)'                                     # 7
-            r'(%(space)s*(?:%(newline)s%(space)s*)+'           # 8
-                r'(?=%(post_regex_off)s))?'
+        r'(%(space)s*(?:(%(newline)s)%(space)s*)*)'  # 5, 6
+        r'(%(regex)s)'  # 7
+        r'(%(space)s*(?:%(newline)s%(space)s*)+'  # 8
+        r'(?=%(post_regex_off)s))?'
         r'|(?<=%(id_literal_close)s)'
-            r'(%(space)s*(?:%(newline)s%(space)s*)+)'          # 9
-            r'(?=%(id_literal_open)s)'
+        r'(%(space)s*(?:%(newline)s%(space)s*)+)'  # 9
+        r'(?=%(id_literal_open)s)'
         r'|(?<=%(id_literal)s)(%(space)s+)(?=%(id_literal)s)'  # 10
-        r'|(?<=\+)(%(space)s+)(?=\+)'                          # 11
-        r'|(?<=-)(%(space)s+)(?=-)'                            # 12
-        r'|(%(space)s+)'                                       # 13
-        r'|((?:%(newline)s%(space)s*)+)'                       # 14
+        r'|(?<=\+)(%(space)s+)(?=\+)'  # 11
+        r'|(?<=-)(%(space)s+)(?=-)'  # 12
+        r'|(%(space)s+)'  # 13
+        r'|((?:%(newline)s%(space)s*)+)'  # 14
     ) % locals()).sub
 
     # print space_sub_banged.__self__.pattern
 
-    keep = _re.compile((
-        r'%(space_chars)s+|%(space_comment_nobang)s+|%(newline)s+'
-        r'|(%(bang_comment)s+)'
-    ) % locals()).sub
+    keep = _re.compile(
+        (r'%(space_chars)s+|%(space_comment_nobang)s+|%(newline)s+'
+         r'|(%(bang_comment)s+)') % locals()).sub
     keeper = lambda m: m.groups()[0] or ''
 
     # print keep.__self__.pattern
@@ -333,16 +320,15 @@ def _make_jsmin(python_only=False):
         # pylint: disable = redefined-outer-name
 
         if keep_bang_comments:
-            return space_sub_banged(
-                space_subber_banged, '\n%s\n' % script
-            ).strip()
+            return space_sub_banged(space_subber_banged,
+                                    '\n%s\n' % script).strip()
         else:
-            return space_sub_simple(
-                space_subber_simple, '\n%s\n' % script
-            ).strip()
+            return space_sub_simple(space_subber_simple,
+                                    '\n%s\n' % script).strip()
 
     return jsmin
 
+
 jsmin = _make_jsmin()
 
 
@@ -403,28 +389,19 @@ def jsmin_for_posers(script, keep_bang_comments=False):
             r'\014\016-\040]|(?:/\*[^*]*\*+(?:[^/*][^*]*\*+)*/)))+(?=-)|(?:['
             r'\000-\011\013\014\016-\040]|(?:/\*[^*]*\*+(?:[^/*][^*]*\*+)*/)'
             r')+|(?:(?:(?://[^\r\n]*)?[\r\n])(?:[\000-\011\013\014\016-\040]'
-            r'|(?:/\*[^*]*\*+(?:[^/*][^*]*\*+)*/))*)+'
-        )
+            r'|(?:/\*[^*]*\*+(?:[^/*][^*]*\*+)*/))*)+')
 
         def subber(match):
             """ Substitution callback """
             groups = match.groups()
-            return (
-                groups[0] or
-                groups[1] or
-                (groups[3] and (groups[2] + '\n')) or
-                groups[2] or
-                (groups[5] and "%s%s%s" % (
-                    groups[4] and '\n' or '',
-                    groups[5],
-                    groups[6] and '\n' or '',
-                )) or
-                (groups[7] and '\n') or
-                (groups[8] and ' ') or
-                (groups[9] and ' ') or
-                (groups[10] and ' ') or
-                ''
-            )
+            return (groups[0] or groups[1]
+                    or (groups[3] and (groups[2] + '\n')) or groups[2]
+                    or (groups[5] and "%s%s%s" % (
+                        groups[4] and '\n' or '',
+                        groups[5],
+                        groups[6] and '\n' or '',
+                    )) or (groups[7] and '\n') or (groups[8] and ' ')
+                    or (groups[9] and ' ') or (groups[10] and ' ') or '')
     else:
         rex = (
             r'([^\047"/\000-\040]+)|((?:(?:\047[^\047\\\r\n]*(?:\\(?:[^\r\n]'
@@ -457,46 +434,39 @@ def jsmin_for_posers(script, keep_bang_comments=False):
             r'11\013\014\016-\040]|(?:/\*[^*]*\*+(?:[^/*][^*]*\*+)*/))+)(?=-'
             r')|((?:[\000-\011\013\014\016-\040]|(?:/\*[^*]*\*+(?:[^/*][^*]*'
             r'\*+)*/))+)|((?:(?:(?://[^\r\n]*)?[\r\n])(?:[\000-\011\013\014'
-            r'\016-\040]|(?:/\*[^*]*\*+(?:[^/*][^*]*\*+)*/))*)+)'
-        )
-
-        keep = _re.compile((
-            r'[\000-\011\013\014\016-\040]+|(?:/\*(?!!)[^*]*\*+(?:[^/*][^*]*'
-            r'\*+)*/)+|(?:(?://[^\r\n]*)?[\r\n])+|((?:/\*![^*]*\*+(?:[^/*][^'
-            r'*]*\*+)*/)+)'
-        ) % locals()).sub
+            r'\016-\040]|(?:/\*[^*]*\*+(?:[^/*][^*]*\*+)*/))*)+)')
+
+        keep = _re.compile(
+            (r'[\000-\011\013\014\016-\040]+|(?:/\*(?!!)[^*]*\*+(?:[^/*][^*]*'
+             r'\*+)*/)+|(?:(?://[^\r\n]*)?[\r\n])+|((?:/\*![^*]*\*+(?:[^/*][^'
+             r'*]*\*+)*/)+)') % locals()).sub
         keeper = lambda m: m.groups()[0] or ''
 
         def subber(match):
             """ Substitution callback """
             groups = match.groups()
-            return (
-                groups[0] or
-                groups[1] or
-                (groups[3] and "%s%s%s%s" % (
-                    keep(keeper, groups[2]),
-                    groups[3],
-                    keep(keeper, groups[4] or ''),
-                    groups[4] and '\n' or '',
-                )) or
-                (groups[7] and "%s%s%s%s%s" % (
-                    keep(keeper, groups[5]),
-                    groups[6] and '\n' or '',
-                    groups[7],
-                    keep(keeper, groups[8] or ''),
-                    groups[8] and '\n' or '',
-                )) or
-                (groups[9] and keep(keeper, groups[9] + '\n')) or
-                (groups[10] and keep(keeper, groups[10]) or ' ') or
-                (groups[11] and keep(keeper, groups[11]) or ' ') or
-                (groups[12] and keep(keeper, groups[12]) or ' ') or
-                keep(keeper, groups[13] or groups[14])
-            )
+            return (groups[0] or groups[1] or (groups[3] and "%s%s%s%s" % (
+                keep(keeper, groups[2]),
+                groups[3],
+                keep(keeper, groups[4] or ''),
+                groups[4] and '\n' or '',
+            )) or (groups[7] and "%s%s%s%s%s" % (
+                keep(keeper, groups[5]),
+                groups[6] and '\n' or '',
+                groups[7],
+                keep(keeper, groups[8] or ''),
+                groups[8] and '\n' or '',
+            )) or (groups[9] and keep(keeper, groups[9] + '\n'))
+                    or (groups[10] and keep(keeper, groups[10]) or ' ')
+                    or (groups[11] and keep(keeper, groups[11]) or ' ')
+                    or (groups[12] and keep(keeper, groups[12]) or ' ')
+                    or keep(keeper, groups[13] or groups[14]))
 
     return _re.sub(rex, subber, '\n%s\n' % script).strip()
 
 
 if __name__ == '__main__':
+
     def main():
         """ Main """
         import sys as _sys
@@ -508,8 +478,7 @@ if __name__ == '__main__':
         else:
             xjsmin = jsmin
 
-        _sys.stdout.write(xjsmin(
-            _sys.stdin.read(), keep_bang_comments=keep_bang_comments
-        ))
+        _sys.stdout.write(
+            xjsmin(_sys.stdin.read(), keep_bang_comments=keep_bang_comments))
 
     main()

package/scripts/eslint_rules/lib/l10n_filename_matches.js

@@ -5,9 +5,6 @@
 'use strict';
 
 const path = require('path');
-const {devtoolsRootPath} = require('../../devtools_paths.js');
-
-const DEFAULT_FRONT_END_DIRECTORY = path.join(devtoolsRootPath(), 'front_end');
 
 function isModuleScope(context) {
   return context.getScope().type === 'module';
@@ -60,10 +57,13 @@ module.exports = {
           return;
         }
 
-        let frontEndDirectory = DEFAULT_FRONT_END_DIRECTORY;
+        let frontEndDirectory = '';
         if (context.options && context.options[0]?.rootFrontendDirectory) {
           frontEndDirectory = context.options[0].rootFrontendDirectory;
         }
+        if (!frontEndDirectory) {
+          throw new Error('rootFrontendDirectory must be provided.');
+        }
         const currentSourceFile = path.resolve(context.getFilename());
         const currentFileRelativeToFrontEnd = path.relative(frontEndDirectory, currentSourceFile);
 

package/scripts/eslint_rules/lib/lit_html_no_attribute_quotes.js

@@ -0,0 +1,101 @@
+// Copyright 2021 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+'use strict';
+
+function isLitHtmlTemplateCall(taggedTemplateExpressionNode) {
+  // Match LitHtml.html``
+  const {tag} = taggedTemplateExpressionNode;
+  if (!tag) {
+    return false;
+  }
+  // Match LitHtml.html``
+  const isLitHtmlDotHtmlCall = tag.object?.name === 'LitHtml' && tag.property?.name === 'html';
+  // Match html`` (and guess that it's Lit)
+  const isDestructuredHtmlCall = tag.type === 'Identifier' && tag.name === 'html';
+
+  return isLitHtmlDotHtmlCall || isDestructuredHtmlCall;
+}
+
+function templateElementPartStartsWithDoubleQuote(templateElementPartNode) {
+  return templateElementPartNode.value.raw.startsWith('"');
+}
+function templateElementPartEndsWithEqualsDoubleQuote(templateElementPartNode) {
+  return templateElementPartNode.value.raw.endsWith('="');
+}
+
+function removeQuotesFromAttribute({fixer, firstPart, secondPart}) {
+  const [, rangeOfOpeningTemplatePartEnd] = firstPart.range;
+  // From the first part, we need to remove the last character, which is the double quote.
+  // We can do this by fetching the range of the node (range = start and end position on the line)
+  // However, for the template part with the opening quote, the range will also contain the ${ of the interpolation:
+  // <p class="${
+  // ^^^^^^^^^^^^ this is the text covered by the [start, end] range.
+  // So what we need to do is remove the quote, and leave the last two characters alone.
+  // Therefore we remove the third character back from the end, and only remove a single character, leaving the ${ part alone.
+  const startingQuoteRangeToRemove = [rangeOfOpeningTemplatePartEnd - 3, rangeOfOpeningTemplatePartEnd - 2];
+
+  const [rangeOfClosingTemplatePartStart] = secondPart.range;
+  // It's a similar story for the second part where the range includes the }:
+  // }">foo</p>
+  // ^^^^^^^^^^ this is the range
+  // So therefore we get the start of the range, and add one to it, to dodge the } character, and then remove only the quote.
+  const endingQuoteRangeToRemove = [rangeOfClosingTemplatePartStart + 1, rangeOfClosingTemplatePartStart + 2];
+
+  return [fixer.removeRange(startingQuoteRangeToRemove), fixer.removeRange(endingQuoteRangeToRemove)];
+}
+
+module.exports = {
+  meta: {
+    type: 'problem',
+
+    docs: {
+      description: 'ensure no extra quotes around attributes when the value is interpolated',
+      category: 'Possible Errors',
+    },
+    fixable: 'code',
+    messages: {
+      attributeQuotesNotRequired:
+          'When interpolating a value as an attribute in LitHtml you do not need double quotes around it.',
+    },
+    schema: []  // no options
+  },
+  create: function(context) {
+    return {
+      TaggedTemplateExpression(node) {
+        if (!isLitHtmlTemplateCall(node)) {
+          return;
+        }
+
+        // quasis here = the static parts of a template expression
+        // expressions = the dynamic parts of a template expression
+        // For example, given: <p class="${foo}"> we will have:
+        // quasis: ['<p class="', '">']
+        // expressions: ['foo'] (it's actually an AST node representing ${foo})
+        // So what we do is walk through and look for quasi pairs where:
+        // 1. the first ends with ="
+        // 2. the second begins with "
+        // We can then be confident that we have found an attribute with quotes around it.
+        node.quasi.quasis.forEach((templateElement, index) => {
+          if (templateElementPartEndsWithEqualsDoubleQuote(templateElement)) {
+            const nextElement = node.quasi.quasis[index + 1];
+            if (nextElement && templateElementPartStartsWithDoubleQuote(nextElement)) {
+              const expressionBetweenTheParts = node.quasi.expressions[index];
+              context.report({
+                node: expressionBetweenTheParts,
+                messageId: 'attributeQuotesNotRequired',
+                fix(fixer) {
+                  return removeQuotesFromAttribute({
+                    fixer,
+                    firstPart: templateElement,
+                    secondPart: nextElement,
+                  });
+                }
+              });
+            }
+          }
+        });
+      },
+    };
+  }
+};