Update PolymerClassDefinition to collect methods from fields and properties assigned to functions.

PiperOrigin-RevId: 845461047

Author: trevorade

src/com/google/javascript/jscomp/PolymerClassDefinition.java

@@ -342,29 +342,20 @@ private static Node createDummyGoogModuleExportsTarget(AbstractCompiler compiler
 
     JSDocInfo classInfo = NodeUtil.getBestJSDocInfo(classNode);
 
-    JSDocInfo ctorInfo = null;
     Node constructor = NodeUtil.getEs6ClassConstructorMemberFunctionDef(classNode);
-    if (constructor != null) {
-      ctorInfo = NodeUtil.getBestJSDocInfo(constructor);
-    }
 
     ImmutableList<MemberDefinition> properties =
         PolymerPassStaticUtils.extractProperties(
             propertiesDescriptor, DefinitionType.ES6Class, compiler, constructor);
 
-    List<MemberDefinition> methods = new ArrayList<>();
-    for (Node keyNode = NodeUtil.getClassMembers(classNode).getFirstChild();
-        keyNode != null;
-        keyNode = keyNode.getNext()) {
-      if (!keyNode.isMemberFunctionDef()) {
-        continue;
-      }
-      methods.add(
-          new MemberDefinition(
-              NodeUtil.getBestJSDocInfo(keyNode),
-              keyNode,
-              keyNode.getFirstChild(),
-              enclosingModule));
+    List<MemberDefinition> methods = extractClassMethods(classNode, enclosingModule);
+
+    JSDocInfo ctorInfo = null;
+    if (constructor != null) {
+      ctorInfo = NodeUtil.getBestJSDocInfo(constructor);
+
+      // Add properties assigned to functions in the constructor (i.e. `this.prop = function`).
+      addFunctionAssignmentsFromConstructor(constructor, enclosingModule, methods);
     }
     CompilerInput input = compiler.getInput(NodeUtil.getEnclosingScript(classNode).getInputId());
 
@@ -385,6 +376,56 @@ private static Node createDummyGoogModuleExportsTarget(AbstractCompiler compiler
         input);
   }
 
+  /** Extracts true class methods and fields assigned to functions from an ES6 class node. */
+  private static List<MemberDefinition> extractClassMethods(Node classNode, Node enclosingModule) {
+    List<MemberDefinition> methods = new ArrayList<>();
+    for (Node keyNode = NodeUtil.getClassMembers(classNode).getFirstChild();
+        keyNode != null;
+        keyNode = keyNode.getNext()) {
+      if (keyNode.isMemberFunctionDef() || isFunctionField(keyNode)) {
+        methods.add(
+            new MemberDefinition(
+                NodeUtil.getBestJSDocInfo(keyNode),
+                keyNode,
+                keyNode.getFirstChild(),
+                enclosingModule));
+      }
+    }
+    return methods;
+  }
+
+  /** Detects patterns like {@code field = function() {}} and {@code field = () => {})}. */
+  private static boolean isFunctionField(Node field) {
+    if (!field.isMemberFieldDef()) {
+      return false;
+    }
+    Node value = field.getFirstChild();
+    return value != null && value.isFunction();
+  }
+
+  /**
+   * Adds properties assigned to functions in the constructor body (e.g., {@code this.prop =
+   * function()}) to the given list of methods.
+   */
+  private static void addFunctionAssignmentsFromConstructor(
+      Node constructor, Node enclosingModule, List<MemberDefinition> methods) {
+    Node body = NodeUtil.getFunctionBody(constructor.getFirstChild());
+    for (Node stmt = body.getFirstChild(); stmt != null; stmt = stmt.getNext()) {
+      if (!stmt.isExprResult() || !stmt.getFirstChild().isAssign()) {
+        continue;
+      }
+
+      var assignment = stmt.getFirstChild();
+      var propName = assignment.getFirstChild();
+      var propValue = assignment.getLastChild();
+      if (propName.isGetProp() && propName.getFirstChild().isThis() && propValue.isFunction()) {
+        methods.add(
+            new MemberDefinition(
+                NodeUtil.getBestJSDocInfo(propName), propName, propValue, enclosingModule));
+      }
+    }
+  }
+
   /**
    * Appends a list of new MemberDefinitions to the end of a list and removes any previous
    * MemberDefinition in the list which has the same name as the new member.

test/com/google/javascript/jscomp/PolymerClassDefinitionTest.java

@@ -15,9 +15,11 @@
  */
 package com.google.javascript.jscomp;
 
+import static com.google.common.collect.ImmutableList.toImmutableList;
 import static com.google.common.truth.Truth.assertThat;
 import static com.google.javascript.rhino.testing.NodeSubject.assertNode;
 
+import com.google.common.collect.ImmutableList;
 import com.google.javascript.jscomp.modules.ModuleMap;
 import com.google.javascript.jscomp.modules.ModuleMetadataMap;
 import com.google.javascript.rhino.Node;
@@ -126,6 +128,41 @@ static get properties() {
     assertThat(def.props).hasSize(2);
   }
 
+  @Test
+  public void testClassMethods() {
+    PolymerClassDefinition def =
+        parseAndExtractClassDefFromClass(
+            """
+            class A extends Polymer.Element {
+              static get is() { return 'x-element'; }
+              method() {}
+              /** @type {function()} */
+              fieldWithFunction = function() {};
+              fieldWithArrowFunction = () => {};
+              fieldWithNumber = 1;
+              fieldWithoutInitializer;
+              constructor() {
+                super();
+                this.propertyWithFunction = function() {};
+                this.propertyWithArrowFunction = () => {};
+                this.propertyWithNumber = 2;
+              }
+            }
+            """);
+
+    assertThat(def).isNotNull();
+    ImmutableList<String> methodNames =
+        def.methods.stream().map(m -> m.name.getString()).collect(toImmutableList());
+    assertThat(methodNames)
+        .containsExactly(
+            "method",
+            "fieldWithFunction",
+            "fieldWithArrowFunction",
+            "constructor",
+            "propertyWithFunction",
+            "propertyWithArrowFunction");
+  }
+
   @Test
   public void testDynamicDescriptor() {
     PolymerClassDefinition def =