Rollforward: Resolve CAST types immediately after evaluation

Currently they are resolved after TypeInference runs on all scopes, in TypeInferencePass.

This is a problem when other code in the TypeInference pass tries to read properties off those types. It causes unknown type warnings when trying to delete InlineTypeAliases.

NEW: loosen Preconditions check to ignore info.hasType() and add some repro test cases

*** Reason for rollback ***

Roll forward with looser Preconditions check

*** Reason for original rollback ***

Caused crash due to a CAST node missing @type JSDocInfo

-------------
Created by MOE: https://github.com/google/moe
MOE_MIGRATED_REVID=233692996

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

@@ -668,8 +668,20 @@ private FlowScope traverse(Node n, FlowScope scope) {
       case CAST:
         scope = traverseChildren(n, scope);
         JSDocInfo info = n.getJSDocInfo();
-        if (info != null && info.hasType()) {
-          n.setJSType(info.getType().evaluate(scope.getDeclarationScope(), registry));
+        // TODO(b/123955687): also check that info.hasType() is true
+        checkNotNull(info, "CAST node should always have JSDocInfo");
+        if (info.hasType()) {
+          // NOTE(lharker) - I tried moving CAST type evaluation into the typed scope creation
+          // phase.
+          // Since it caused a few new, seemingly spurious, 'Bad type annotation' and
+          // 'unknown property type' warnings, and having it in TypeInference seems to work, we just
+          // do the lookup + resolution here.
+          n.setJSType(
+              info.getType()
+                  .evaluate(scope.getDeclarationScope(), registry)
+                  .resolve(registry.getErrorReporter()));
+        } else {
+          n.setJSType(unknownType);
         }
         break;
 

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

@@ -331,13 +331,15 @@ public void testObjDestructuringConst() {
   public void testConstructorCycle() {
     CompilerOptions options = createCompilerOptions();
     options.setCheckTypes(true);
-    test(
+    testNoWarnings(
         options,
-        "/** @return {function()} */ var AsyncTestCase = function() {};\n"
-        + "/**\n"
-        + " * @constructor\n"
-        + " */ Foo = /** @type {function(new:Foo)} */ (AyncTestCase());",
-        RhinoErrorReporter.PARSE_ERROR);
+        lines(
+            "/** @return {function()} */",
+            "var AsyncTestCase = function() {};",
+            "/**",
+            " * @constructor",
+            " */",
+            "const Foo = /** @type {function(new:Foo)} */ (AsyncTestCase());"));
   }
 
   // b/27531865

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

@@ -11643,6 +11643,34 @@ public void testCast34b() {
         "var y = /** @type {Object} */(x);");
   }
 
+  @Test
+  public void testCastToNameRequiringPropertyResolution() {
+    // regression test for correctly typing properties off of types in CASTs.
+    // The type JSDoc in a cast is currently evaluated during TypeInference. In the past any
+    // 'unresolved' types in cast JSDoc were not resolved until after type inference completed. This
+    // caused type inference to infer properties off of those unresolved types as unknown.
+    testTypesWithExterns(
+        "var unknownVar;",
+        lines(
+            "const foo = {bar: {}};",
+            "const bar = foo.bar;",
+            "bar.Class = class {",
+            "  /** @return {number} */",
+            "  id() { return 0; }",
+            "};",
+            // Because `foo.bar.Class = ...` was never directly assigned, the type 'foo.bar.Class'
+            // is not in the JSTypeRegistry. It's resolved through NamedType#resolveViaProperty.
+            // The same thing would have occurred if we assigned 'foo.bar.Class = ...' then
+            // referred to '!bar.Class' in the JSDoc.
+            // Verify that type inference correctly infers the id property's type.
+
+            "const /** null */ n = /** @type {!foo.bar.Class} */ (unknownVar).id;"),
+        lines(
+            "initializing variable", //
+            "found   : function(this:bar.Class): number",
+            "required: null"));
+  }
+
   @Test
   public void testNestedCasts() {
     testTypes("/** @constructor */var T = function() {};\n" +
@@ -22751,6 +22779,22 @@ public void testCastOnLhsOfAssignBlocksBadAssignmentWarning() {
     testTypes("var /** number */ x = 1; (/** @type {?} */ (x)) = 'foobar';");
   }
 
+  @Test
+  public void testCastOnLhsWithAdditionalJSDoc() {
+    // TODO(b/123955687): this should issue a type error because Foo.prototype.takesString is passed
+    // a number
+    testTypes(
+        lines(
+            "class Foo {",
+            "  takesString(/** string */ stringParameter) {}",
+            "}",
+            "/** @param {*} all */",
+            "function f(all) {",
+            "  /** some jsdoc */",
+            "  (/** @type {!Foo} */ (all)).takesString(0);",
+            "}"));
+  }
+
   @Test
   public void testInvalidComparisonsInStrictOperatorsMode() {
     testTypes(

test/com/google/javascript/jscomp/parsing/ParserTest.java

@@ -967,7 +967,7 @@ public void testJSDocAttachment16() {
   }
 
   @Test
-  public void testJSDocAttachment17() {
+  public void testJSDocAttachmentForCastFnCall() {
     Node fn =
         parse(
             "function f() { " +
@@ -979,7 +979,7 @@ public void testJSDocAttachment17() {
   }
 
   @Test
-  public void testJSDocAttachment18() {
+  public void testJSDocAttachmentForCastName() {
     Node fn =
         parse(
             "function f() { " +
@@ -990,6 +990,17 @@ public void testJSDocAttachment18() {
     assertNode(cast).hasType(Token.CAST);
   }
 
+  @Test
+  public void testJSDocAttachmentForCastLhs() {
+    Node expr = parse("/** some jsdoc */ (/** @type {?} */ (a)).b = 0;").getOnlyChild();
+    Node lhs = expr.getFirstFirstChild(); // child is ASSIGN, grandchild is the GETPROP
+    Node cast = lhs.getFirstChild();
+    assertNode(cast).hasToken(Token.CAST);
+    assertThat(cast.getJSDocInfo()).isNotNull();
+    // TODO(b/123955687): this should be true
+    assertThat(cast.getJSDocInfo().hasType()).isFalse();
+  }
+
   @Test
   public void testJSDocAttachment19() {
     Node fn =