Don't propagate loose types to declared property slots. This generally improves type checking around property assignments in local scope. This also revealed a problem with @implictCast property handling in local scope, and that is fixed here as well.

-------------
Created by MOE: http://code.google.com/p/moe-java
MOE_MIGRATED_REVID=88979120

Author: concavelenz

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

@@ -109,20 +109,21 @@ public void inferSlotType(String symbol, JSType type) {
 
   @Override
   public void inferQualifiedSlot(Node node, String symbol, JSType bottomType,
-      JSType inferredType) {
+      JSType inferredType, boolean declared) {
     TypedScope functionScope = getFunctionScope();
     if (functionScope.isLocal()) {
       TypedVar v  = functionScope.getVar(symbol);
       if (v == null && !functionScope.isBottom()) {
-        functionScope.declare(symbol, node, bottomType, null);
+        v = functionScope.declare(symbol, node, bottomType, null, !declared);
       }
 
       if (v != null && !v.isTypeInferred()) {
         JSType declaredType = v.getType();
         // Use the inferred type over the declared type only if the
         // inferred type is a strict subtype of the declared type.
         if (declaredType != null && inferredType.isSubtype(declaredType)
-            && !declaredType.isSubtype(inferredType)) {
+            && !declaredType.isSubtype(inferredType)
+            && !inferredType.isEquivalentTo(declaredType)) {
           inferSlotType(symbol, inferredType);
         }
       } else {

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

@@ -944,15 +944,16 @@ private void visitAssign(NodeTraversal t, Node assign) {
           objectJsType.restrictByNotNullOrUndefined());
       if (type != null) {
         if (type.hasProperty(pname) &&
-            !type.isPropertyTypeInferred(pname) &&
-            !propertyIsImplicitCast(type, pname)) {
+            !type.isPropertyTypeInferred(pname)) {
           JSType expectedType = type.getPropertyType(pname);
           if (!expectedType.isUnknownType()) {
-            validator.expectCanAssignToPropertyOf(
-                t, assign, getJSType(rvalue),
-                expectedType, object, pname);
-            checkPropertyInheritanceOnGetpropAssign(
-                t, assign, object, pname, info, expectedType);
+            if (!propertyIsImplicitCast(type, pname)) {
+              validator.expectCanAssignToPropertyOf(
+                  t, assign, getJSType(rvalue),
+                  expectedType, object, pname);
+              checkPropertyInheritanceOnGetpropAssign(
+                  t, assign, object, pname, info, expectedType);
+            }
             return;
           }
         }

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

@@ -595,9 +595,18 @@ private void updateScopeForTypeChange(
       case Token.GETPROP:
         String qualifiedName = left.getQualifiedName();
         if (qualifiedName != null) {
-          scope.inferQualifiedSlot(left, qualifiedName,
-              leftType == null ? unknownType : leftType,
-              resultType);
+          boolean declaredSlotType = false;
+          JSType rawObjType = left.getFirstChild().getJSType();
+          if (rawObjType != null) {
+            ObjectType objType = ObjectType.cast(
+                rawObjType.restrictByNotNullOrUndefined());
+            if (objType != null) {
+              String propName = left.getLastChild().getString();
+              declaredSlotType = objType.isPropertyTypeDeclared(propName);
+            }
+          }
+          JSType safeLeftType = leftType == null ? unknownType : leftType;
+          scope.inferQualifiedSlot(left, qualifiedName, safeLeftType, resultType, declaredSlotType);
         }
 
         left.setJSType(resultType);
@@ -825,7 +834,7 @@ private FlowScope traverseObjectLiteral(Node n, FlowScope scope) {
 
           scope.inferQualifiedSlot(name, qKeyName,
               oldType == null ? unknownType : oldType,
-              valueType);
+              valueType, false);
         }
       } else {
         n.setJSType(unknownType);
@@ -976,7 +985,7 @@ private FlowScope narrowScope(FlowScope scope, Node node, JSType narrowed) {
     scope = scope.createChildFlowScope();
     if (node.isGetProp()) {
       scope.inferQualifiedSlot(
-          node, node.getQualifiedName(), getJSType(node), narrowed);
+          node, node.getQualifiedName(), getJSType(node), narrowed, false);
     } else {
       redeclareSimpleVar(scope, node, narrowed);
     }

src/com/google/javascript/jscomp/type/ChainableReverseAbstractInterpreter.java

@@ -164,7 +164,7 @@ protected void declareNameInScope(FlowScope scope, Node node, JSType type) {
 
         JSType origType = node.getJSType();
         origType = origType == null ? getNativeType(UNKNOWN_TYPE) : origType;
-        scope.inferQualifiedSlot(node, qualifiedName, origType, type);
+        scope.inferQualifiedSlot(node, qualifiedName, origType, type, false);
         break;
 
       case Token.THIS:

src/com/google/javascript/jscomp/type/FlowScope.java

@@ -57,7 +57,7 @@ public interface FlowScope extends StaticTypedScope<JSType>, LatticeElement {
    * inferred.
    */
   void inferQualifiedSlot(Node node, String symbol, JSType bottomType,
-      JSType inferredType);
+      JSType inferredType, boolean declare);
 
   /**
    * Optimize this scope and return a new FlowScope with faster lookup.

src/com/google/javascript/jscomp/type/SemanticReverseAbstractInterpreter.java

@@ -490,7 +490,7 @@ private FlowScope caseIn(Node object, String propertyName, FlowScope blindScope)
           JSType unknownType = typeRegistry.getNativeType(
               JSTypeNative.UNKNOWN_TYPE);
           informed.inferQualifiedSlot(
-              object, propertyQualifiedName, unknownType, unknownType);
+              object, propertyQualifiedName, unknownType, unknownType, false);
           return informed;
         }
       }

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

@@ -825,6 +825,39 @@ public void testQualifiedNameReduction10() throws Exception {
         "required: string");
   }
 
+  public void testUnknownsDontOverrideDeclaredTypesInLocalScope1() throws Exception {
+    testTypes(
+        "/** @constructor */ var C = function() {\n"
+        + "  /** @type {string} */ this.a = 'str'};\n"
+        + "/** @param {?} a\n @return {number} */\n"
+        + "C.prototype.f = function(a) {\n"
+        + "  this.a = a;\n"
+        + "  return this.a;\n"
+        + "}\n",
+
+        "inconsistent return type\n"
+        + "found   : string\n"
+        + "required: number");
+  }
+
+  public void testUnknownsDontOverrideDeclaredTypesInLocalScope2() throws Exception {
+    testTypes(
+        "/** @constructor */ var C = function() {\n"
+        + "  /** @type {string} */ this.a = 'str';\n"
+        + "};\n"
+        + "/** @type {C} */ var x = new C();"
+        + "/** @param {?} a\n @return {number} */\n"
+        + "C.prototype.f = function(a) {\n"
+        + "  x.a = a;\n"
+        + "  return x.a;\n"
+        + "}\n",
+
+        "inconsistent return type\n"
+        + "found   : string\n"
+        + "required: number");
+  }
+
+
   public void testObjLitDef1a() throws Exception {
     testTypes(
         "var x = {/** @type {number} */ a:12 };\n" +
@@ -6340,14 +6373,30 @@ public void testSwitchCase8() throws Exception {
         "required: number");
   }
 
-  public void testImplicitCast() throws Exception {
+  public void testImplicitCast1() throws Exception {
     testTypesWithExterns("/** @constructor */ function Element() {};\n" +
              "/** @type {string}\n" +
              "  * @implicitCast */" +
              "Element.prototype.innerHTML;",
              "(new Element).innerHTML = new Array();");
   }
 
+  public void testImplicitCast2() throws Exception {
+    testTypesWithExterns(
+        "/** @constructor */ function Element() {};\n" +
+        "/**\n" +
+        " * @type {string}\n" +
+        " * @implicitCast\n" +
+        " */\n" +
+        "Element.prototype.innerHTML;\n",
+        "/** @constructor */ function C(e) {\n" +
+        "  /** @type {Element} */ this.el = e;\n" +
+        "}\n" +
+        "C.prototype.method = function() {\n" +
+        "  this.el.innerHTML = new Array();\n" +
+        "};\n");
+  }
+
   public void testImplicitCastSubclassAccess() throws Exception {
     testTypesWithExterns("/** @constructor */ function Element() {};\n" +
              "/** @type {string}\n" +

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

@@ -275,7 +275,7 @@ public void testPropertyInference3() {
         createUndefinableType(STRING_TYPE), null);
     assumingThisType(thisType);
     inFunction("var y = 1; this.foo = x; y = this.foo;");
-    verify("y", CHECKED_UNKNOWN_TYPE);
+    verify("y", createUndefinableType(STRING_TYPE));
   }
 
   public void testAssert1() {