chrome-devtools-frontend 1.0.997598 → 1.0.998045

package/scripts/eslint_rules/lib/lit_template_result_or_nothing.js

@@ -0,0 +1,140 @@
+// Copyright 2020 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';
+
+module.exports = {
+  meta: {
+    type: 'problem',
+
+    docs: {
+      description: 'Enforce use of LitHtml.LitTemplate type rather than union with LitHtml.nothing',
+      category: 'Possible Errors',
+    },
+    fixable: 'code',
+    messages: {
+      useLitTemplateOverEmptyObject:
+          'Prefer LitHtml.LitTemplate type over a union with {}',
+      useLitTemplateOverTypeOfNothing:
+          'Prefer LitHtml.LitTemplate type over a union with LitHtml.nothing',
+    },
+    schema: []  // no options
+  },
+  create: function(context) {
+    const sourceCode = context.getSourceCode();
+    const UNION_TYPE_FOR_LIT_TEMPLATE = 'LitHtml.LitTemplate';
+
+    function checkUnionReturnTypeForLit(node) {
+      // We want to go through the types in the union and match if:
+      // 1. We find `LitHtml.TemplateResult` and `{}`
+      // 2. We find `LitHtml.TemplateResult` and `LitHtml.nothing`.
+      // Otherwise, this node is OK.
+
+      let templateResultNode = null;
+      let literalEmptyObjectNode = null;
+      let litNothingNode = null;
+
+      const nonLitRelatedNodesInUnion = new Set();
+
+      for (const typeNode of node.types) {
+        // This matches a type reference of X.y. Now we see if X === 'LitHtml' and y === 'TemplateResult'
+        if (typeNode.type === 'TSTypeReference' && typeNode.typeName.type === 'TSQualifiedName') {
+          const leftText = typeNode.typeName.left.name;
+          const rightText = typeNode.typeName.right.name;
+          if (leftText === 'LitHtml' && rightText === 'TemplateResult') {
+            templateResultNode = typeNode;
+            continue;
+          }
+        } else if (typeNode.type === 'TSTypeLiteral') {
+          // The TSTypeLiteral type matches against the literal `{}` type.
+          literalEmptyObjectNode = typeNode;
+          continue;
+        } else if (typeNode.type === 'TSTypeQuery' && typeNode.exprName.type === 'TSQualifiedName') {
+          // matches `typeof X.y`
+          const leftText = typeNode.exprName.left.name;
+          const rightText = typeNode.exprName.right.name;
+          if (leftText === 'LitHtml' && rightText === 'nothing') {
+            litNothingNode = typeNode;
+            continue;
+          }
+        }
+
+        nonLitRelatedNodesInUnion.add(typeNode);
+      }
+
+      // We didn't find LitHtml.TemplateResult, so bail.
+      if (!templateResultNode) {
+        return;
+      }
+
+      if (!litNothingNode && !literalEmptyObjectNode) {
+        // We found TemplateResult with no `typeof LitHtml.nothing` or `{}`, so
+        // bail.
+        return;
+      }
+
+      // If we found a union type of:
+      // LitHtml.TemplateResult|{}|number
+      // That needs to become:
+      // LitHtml.LitTemplate|number
+      // So we capture all the non-lit related types in the union, and get
+      // their text content, so we can keep them around when we run the fixer.
+      const nonLitRelatedTypesToKeep = Array.from(nonLitRelatedNodesInUnion, node => {
+        return sourceCode.getText(node);
+      });
+      const newText = [UNION_TYPE_FOR_LIT_TEMPLATE, ...nonLitRelatedTypesToKeep].join('|');
+
+      context.report({
+        node,
+        messageId: litNothingNode ? 'useLitTemplateOverTypeOfNothing' : 'useLitTemplateOverEmptyObject',
+        fix(fixer) {
+          return fixer.replaceText(node, newText);
+        }
+      });
+    }
+
+    function checkTSTypeAnnotationForPotentialIssue(node) {
+      const annotation = node.typeAnnotation;
+      if (annotation.type === 'TSUnionType') {
+        // matches foo(): X|Y
+        checkUnionReturnTypeForLit(annotation);
+      } else if (annotation.type === 'TSTypeReference') {
+        // matches many things, including foo(): Promise<X|Y>, which we do want
+        // to check.
+
+        if (annotation.typeName.name !== 'Promise') {
+          // If it's not a promise, bail out.
+          return;
+        }
+        // Represents the generic type passed to the promise: if our code is
+        // Promise<X>, this node represents the X.
+        const promiseGenericNode = annotation.typeParameters.params[0];
+        if (promiseGenericNode && promiseGenericNode.type === 'TSUnionType') {
+          checkUnionReturnTypeForLit(promiseGenericNode);
+        }
+      }
+    }
+
+    function checkFunctionDeclarationOrExpressionForUnionType(node) {
+      if (node.returnType.type !== 'TSTypeAnnotation') {
+        return;
+      }
+      checkTSTypeAnnotationForPotentialIssue(node.returnType);
+    }
+
+    return {
+      // function() {}
+      FunctionDeclaration(node) {
+        checkFunctionDeclarationOrExpressionForUnionType(node);
+      },
+      // Match functions defined inside classes
+      FunctionExpression(node) {
+        checkFunctionDeclarationOrExpressionForUnionType(node);
+      },
+      // Match values in interfaces or types.
+      TSPropertySignature(node) {
+        checkTSTypeAnnotationForPotentialIssue(node.typeAnnotation);
+      },
+    };
+  }
+};

package/scripts/eslint_rules/lib/no_only_eslint_tests.js

@@ -17,6 +17,10 @@ module.exports = {
   create: function(context) {
     function checkForOnlyInTestCases(testCaseObjects) {
       for (const testCase of testCaseObjects) {
+        if (!testCase || !testCase.properties) {
+          continue;
+        }
+
         const onlyKeyProp = testCase.properties.find(prop => {
           return prop.key.name === 'only';
         });
@@ -37,7 +41,7 @@ module.exports = {
         // second argument = rule itself
         // third argument = the object containing the test cases - what we want!
         const tests = node.arguments[2];
-        if (!tests) {
+        if (!tests || !tests.properties) {
           return;
         }
 

package/scripts/eslint_rules/tests/lit_template_result_or_nothing_test.js

@@ -0,0 +1,133 @@
+// Copyright 2020 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';
+
+const rule = require('../lib/lit_template_result_or_nothing.js');
+const ruleTester = new (require('eslint').RuleTester)({
+  parserOptions: {ecmaVersion: 9, sourceType: 'module'},
+  parser: require.resolve('@typescript-eslint/parser'),
+});
+
+ruleTester.run('lit_template_result_or_nothing', rule, {
+  valid: [
+    {
+      code: 'function foo(): LitHtml.LitTemplate {}',
+      filename: 'front_end/components/datagrid.ts',
+    },
+    {
+      code: 'function foo(): Promise<LitHtml.LitTemplate> {}',
+      filename: 'front_end/components/datagrid.ts',
+    },
+    {
+      code: 'function foo(): Promise<LitHtml.LitTemplate|SomeOtherType> {}',
+      filename: 'front_end/components/datagrid.ts',
+    },
+    {
+      code: 'function foo(): LitHtml.LitTemplate|string {}',
+      filename: 'front_end/components/datagrid.ts',
+    },
+    {
+      code: 'function foo(): LitHtml.TemplateResult|string {}',
+      filename: 'front_end/components/datagrid.ts',
+    },
+  ],
+  invalid: [
+    {
+      code: 'function foo(): LitHtml.TemplateResult|{} {}',
+      filename: 'front_end/components/datagrid.ts',
+      errors: [{messageId: 'useLitTemplateOverEmptyObject'}],
+      output: 'function foo(): LitHtml.LitTemplate {}',
+    },
+    {
+      code: 'function foo(): LitHtml.TemplateResult|{}|number {}',
+      filename: 'front_end/components/datagrid.ts',
+      errors: [{messageId: 'useLitTemplateOverEmptyObject'}],
+      output: 'function foo(): LitHtml.LitTemplate|number {}',
+    },
+    {
+      code: 'function foo(): LitHtml.TemplateResult|typeof LitHtml.nothing {}',
+      filename: 'front_end/components/datagrid.ts',
+      errors: [{messageId: 'useLitTemplateOverTypeOfNothing'}],
+      output: 'function foo(): LitHtml.LitTemplate {}',
+    },
+    {
+      code: 'function foo(): LitHtml.TemplateResult|typeof LitHtml.nothing|number {}',
+      filename: 'front_end/components/datagrid.ts',
+      errors: [{messageId: 'useLitTemplateOverTypeOfNothing'}],
+      output: 'function foo(): LitHtml.LitTemplate|number {}',
+    },
+    {
+      code: 'function foo(): typeof LitHtml.nothing|LitHtml.TemplateResult {}',
+      filename: 'front_end/components/datagrid.ts',
+      errors: [{messageId: 'useLitTemplateOverTypeOfNothing'}],
+      output: 'function foo(): LitHtml.LitTemplate {}',
+    },
+    {
+      code: `class Bar {
+        foo(): typeof LitHtml.nothing|LitHtml.TemplateResult {}
+      }`,
+      filename: 'front_end/components/datagrid.ts',
+      errors: [{messageId: 'useLitTemplateOverTypeOfNothing'}],
+      output: `class Bar {
+        foo(): LitHtml.LitTemplate {}
+      }`,
+    },
+    {
+      code: `class Bar {
+        #foo(): typeof LitHtml.nothing|LitHtml.TemplateResult {}
+      }`,
+      filename: 'front_end/components/datagrid.ts',
+      errors: [{messageId: 'useLitTemplateOverTypeOfNothing'}],
+      output: `class Bar {
+        #foo(): LitHtml.LitTemplate {}
+      }`,
+    },
+    {
+      code: `class Bar {
+        #foo(): LitHtml.TemplateResult|{} {}
+      }`,
+      filename: 'front_end/components/datagrid.ts',
+      errors: [{messageId: 'useLitTemplateOverEmptyObject'}],
+      output: `class Bar {
+        #foo(): LitHtml.LitTemplate {}
+      }`,
+    },
+    {
+      code: 'function foo(): Promise<LitHtml.TemplateResult|{}> {}',
+      filename: 'front_end/components/datagrid.ts',
+      errors: [{messageId: 'useLitTemplateOverEmptyObject'}],
+      output: 'function foo(): Promise<LitHtml.LitTemplate> {}',
+    },
+    {
+      code: `interface Foo {
+        someThing: LitHtml.TemplateResult|typeof LitHtml.nothing;
+      }`,
+      filename: 'front_end/components/datagrid.ts',
+      errors: [{messageId: 'useLitTemplateOverTypeOfNothing'}],
+      output: `interface Foo {
+        someThing: LitHtml.LitTemplate;
+      }`,
+    },
+    {
+      code: `interface Foo {
+        someThing: Promise<LitHtml.TemplateResult|{}>;
+      }`,
+      filename: 'front_end/components/datagrid.ts',
+      errors: [{messageId: 'useLitTemplateOverEmptyObject'}],
+      output: `interface Foo {
+        someThing: Promise<LitHtml.LitTemplate>;
+      }`,
+    },
+    {
+      code: `type Foo = {
+        someThing: LitHtml.TemplateResult|typeof LitHtml.nothing;
+      }`,
+      filename: 'front_end/components/datagrid.ts',
+      errors: [{messageId: 'useLitTemplateOverTypeOfNothing'}],
+      output: `type Foo = {
+        someThing: LitHtml.LitTemplate;
+      }`,
+    },
+  ]
+});

package/scripts/hosted_mode/server.js

@@ -55,7 +55,7 @@ server.once('listening', () => {
   }
   console.log(`Started hosted mode server at http://localhost:${actualPort}\n`);
   console.log('For info on using the hosted mode server, see our contributing docs:');
-  console.log('https://bit.ly/devtools-contribution-guide');
+  console.log('https://goo.gle/devtools-contribution-guide');
   console.log('Tip: Look for the \'Development server options\' section\n');
 });
 const wss = new WebSocketServer({server});