GlobalNamespace: handle properties defined in nested object literals correctly

A previous fix prevented incorrect collapsing of cases like this:

```
const X = typeof OtherThing != 'undefined' ? OtherThing : {prop: 1};
```

However, it didn't handle nested object literals correctly.

```
const X = typeof OtherThing != 'undefined' ? OtherThing : {prop: {nested: 1}};
```

This change expands the fix to the more general case.

PiperOrigin-RevId: 501412585

Author: brad4d

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

@@ -137,7 +137,7 @@ static SourceKind fromScriptNode(Node n) {
    * @param root The root of the rest of the code to build a namespace for.
    */
   GlobalNamespace(AbstractCompiler compiler, Node root) {
-    this(/* decisionsLog = */ null, compiler, null, root);
+    this(/* decisionsLog= */ null, compiler, null, root);
   }
 
   /**
@@ -1173,25 +1173,25 @@ private enum DeclaredTypeKind {
    */
   enum Inlinability {
     INLINE_COMPLETELY(
-        /* shouldInlineUsages = */ true,
+        /* shouldInlineUsages= */ true,
         /* shouldRemoveDeclaration= */ true,
-        /* canCollapse = */ true),
+        /* canCollapse= */ true),
     INLINE_BUT_KEEP_DECLARATION_ENUM(
-        /* shouldInlineUsages = */ true,
+        /* shouldInlineUsages= */ true,
         /* shouldRemoveDeclaration= */ false,
-        /* canCollapse = */ true),
+        /* canCollapse= */ true),
     INLINE_BUT_KEEP_DECLARATION_INTERFACE(
-        /* shouldInlineUsages = */ true,
+        /* shouldInlineUsages= */ true,
         /* shouldRemoveDeclaration= */ false,
-        /* canCollapse = */ true),
+        /* canCollapse= */ true),
     INLINE_BUT_KEEP_DECLARATION_CLASS(
-        /* shouldInlineUsages = */ true,
+        /* shouldInlineUsages= */ true,
         /* shouldRemoveDeclaration= */ false,
-        /* canCollapse = */ true),
+        /* canCollapse= */ true),
     DO_NOT_INLINE(
-        /* shouldInlineUsages = */ false,
+        /* shouldInlineUsages= */ false,
         /* shouldRemoveDeclaration= */ false,
-        /* canCollapse = */ false);
+        /* canCollapse= */ false);
 
     private final boolean shouldInlineUsages;
     private final boolean shouldRemoveDeclaration;
@@ -1771,8 +1771,10 @@ Inlinability canCollapseOrInline() {
             logDecision(Inlinability.DO_NOT_INLINE, "obj lit property followed by spread");
             return Inlinability.DO_NOT_INLINE;
           }
-          Node grandparent = declaration.getGrandparent();
-          if (grandparent.isOr() || grandparent.isHook()) {
+          // We may be in a deeply nested object literal like, `{a: {b: {c: 1}}}`, so find the
+          // outermost object literal node in order to determine whether it is used conditionally.
+          final Node objectLitParent = getOutermostObjectLit(declaration).getParent();
+          if (objectLitParent.isOr() || objectLitParent.isHook()) {
             // Case: `var x = y || {a: b}` or `var x = cond ? y : {a: b}`.
             logDecision(Inlinability.DO_NOT_INLINE, "conditional definition");
             return Inlinability.DO_NOT_INLINE;
@@ -2191,6 +2193,26 @@ boolean isModuleExport() {
     }
   }
 
+  /**
+   * Given something like the `'c'` STRING_KEY node in `x = {a: {b: {c: 0}}};`, return the Node for
+   * the outermost object literal.
+   *
+   * @param objLitKey Must be the child of an OBJECT_LIT node
+   * @return The first ancestor that is an OBJECT_LIT and whose grandparent is not an OBJECT_LIT
+   */
+  private Node getOutermostObjectLit(Node objLitKey) {
+    Node outermostObjectLit = objLitKey.getParent();
+    checkState(outermostObjectLit.isObjectLit(), outermostObjectLit);
+    while (true) {
+      final Node objLitGrandparent = outermostObjectLit.getGrandparent();
+      if (objLitGrandparent != null && objLitGrandparent.isObjectLit()) {
+        outermostObjectLit = objLitGrandparent;
+      } else {
+        return outermostObjectLit;
+      }
+    }
+  }
+
   /**
    * True if the given Node is the GETPROP in a statement like `some.q.name;`
    *
@@ -2400,7 +2422,7 @@ static ObjLitStringKeyAnalysis forObjLitAssignment(String nameString, NameType n
     /** The object literal key does not represent a qualified name assignment. */
     static ObjLitStringKeyAnalysis forNonReference() {
       return new AutoValue_GlobalNamespace_ObjLitStringKeyAnalysis(
-          /* nameString = */ null, NameType.OTHER);
+          /* nameString= */ null, NameType.OTHER);
     }
   }
 }

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

@@ -4420,6 +4420,11 @@ public void testTernaryExpression() {
     // right branch, write to undeclared prop
     test(
         srcs("var a = p ? x : {b: 1}; a.c = 2;"), expected("var a = p ? x : {b: 1}; var a$c = 2;"));
+
+    // right branch, use nested prop, alias is inlined but prop is not collapsed.
+    test(
+        srcs("    var a = p ? x : {b: { insideB: 1 }}; var t = a.b.insideB; use(          t);"),
+        expected("var a = p ? x : {b: { insideB: 1 }}; var t = null       ; use(a.b.insideB);"));
   }
 
   @Test

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

@@ -1061,6 +1061,26 @@ public void testCannotCollapseAliasedObjectLitProperty() {
     assertThat(fooProp.canCollapse()).isFalse();
   }
 
+  @Test
+  public void testCannotCollapseConditionalObjectLitProperty() {
+    GlobalNamespace namespace = parse("var foo = x || {prop: 0}; use(foo.prop);");
+
+    Name fooProp = namespace.getSlot("foo.prop");
+
+    // We should not convert foo.prop -> foo$prop because use(foo) might read foo.prop
+    assertThat(fooProp.canCollapse()).isFalse();
+  }
+
+  @Test
+  public void testCannotCollapseConditionalObjectLitNestedProperty() {
+    GlobalNamespace namespace = parse("var foo = x || {prop: {nested: 0}}; use(foo.prop.nested);");
+
+    Name fooProp = namespace.getSlot("foo.prop.nested");
+
+    // We should not convert foo.prop -> foo$prop because use(foo) might read foo.prop
+    assertThat(fooProp.canCollapse()).isFalse();
+  }
+
   @Test
   public void testGitHubIssue3733() {
     GlobalNamespace namespace =