1) Stronger assertions in MakeCallsStatic to ensure clinits don't get messed up.
2) Removed old instantiability pruning from Pruner; TypeTightener's FixDanglingRefs should take care of what that used to accomplish.
3) TypeTightener's getSingleConcrete stuff should now work ONLY for instantiable types.

Review by: bobv (postmortem, see r1799)


git-svn-id: https://google-web-toolkit.googlecode.com/svn/trunk@1793 8db76d5a-ed1c-0410-87a9-c151d255dfc7
diff --git a/dev/core/src/com/google/gwt/dev/jjs/impl/MakeCallsStatic.java b/dev/core/src/com/google/gwt/dev/jjs/impl/MakeCallsStatic.java
index b501501..85b56af 100644
--- a/dev/core/src/com/google/gwt/dev/jjs/impl/MakeCallsStatic.java
+++ b/dev/core/src/com/google/gwt/dev/jjs/impl/MakeCallsStatic.java
@@ -132,7 +132,7 @@
       JType returnType = x.getType();
       SourceInfo sourceInfo = x.getSourceInfo();
       int myIndexInClass = enclosingType.methods.indexOf(x);
-      assert (myIndexInClass >= 0);
+      assert (myIndexInClass > 0);
 
       // Create the new static method
       String newName = "$" + x.getName();
@@ -236,6 +236,8 @@
         return;
       }
 
+      assert (method.getEnclosingType().methods.indexOf(method) > 0);
+
       // Let's do it!
       toBeMadeStatic.add(method);
     }
diff --git a/dev/core/src/com/google/gwt/dev/jjs/impl/Pruner.java b/dev/core/src/com/google/gwt/dev/jjs/impl/Pruner.java
index 043de05..346dba3 100644
--- a/dev/core/src/com/google/gwt/dev/jjs/impl/Pruner.java
+++ b/dev/core/src/com/google/gwt/dev/jjs/impl/Pruner.java
@@ -207,14 +207,11 @@
 
     @Override
     public boolean visit(JClassType type, Context ctx) {
-
       assert (referencedTypes.contains(type));
-      boolean isInstantiated = program.typeOracle.isInstantiatedType(type);
 
       for (Iterator<JField> it = type.fields.iterator(); it.hasNext();) {
         JField field = it.next();
-        if (!referencedNonTypes.contains(field)
-            || pruneViaNoninstantiability(isInstantiated, field)) {
+        if (!referencedNonTypes.contains(field)) {
           it.remove();
           didChange = true;
         }
@@ -222,8 +219,7 @@
 
       for (Iterator<JMethod> it = type.methods.iterator(); it.hasNext();) {
         JMethod method = it.next();
-        if (!methodIsReferenced(method)
-            || pruneViaNoninstantiability(isInstantiated, method)) {
+        if (!methodIsReferenced(method)) {
           it.remove();
           didChange = true;
         } else {
diff --git a/dev/core/src/com/google/gwt/dev/jjs/impl/TypeTightener.java b/dev/core/src/com/google/gwt/dev/jjs/impl/TypeTightener.java
index 7d6afb6..09b712d 100644
--- a/dev/core/src/com/google/gwt/dev/jjs/impl/TypeTightener.java
+++ b/dev/core/src/com/google/gwt/dev/jjs/impl/TypeTightener.java
@@ -199,9 +199,11 @@
 
     @Override
     public void endVisit(JClassType x, Context ctx) {
-      for (JClassType cur = x; cur != null; cur = cur.extnds) {
-        addImplementor(cur, x);
-        addInterfacesImplementorRecursive(cur, x);
+      if (program.typeOracle.isInstantiatedType(x)) {
+        for (JClassType cur = x; cur != null; cur = cur.extnds) {
+          addImplementor(cur, x);
+          addInterfacesImplementorRecursive(cur, x);
+        }
       }
     }
 
@@ -223,8 +225,10 @@
 
     @Override
     public void endVisit(JMethod x, Context ctx) {
-      for (JMethod method : program.typeOracle.getAllOverrides(x)) {
-        addOverrider(method, x);
+      if (program.typeOracle.isInstantiatedType(x.getEnclosingType())) {
+        for (JMethod method : program.typeOracle.getAllOverrides(x)) {
+          addOverrider(method, x);
+        }
       }
       currentMethod = null;
     }
@@ -493,20 +497,6 @@
      */
     @Override
     public void endVisit(JMethod x, Context ctx) {
-      JClassType concreteType = getSingleConcreteType(x.getType());
-      if (concreteType != null) {
-        x.setType(concreteType);
-        myDidChange = true;
-      }
-
-      /*
-       * The only information that we can infer about native methods is if they
-       * are declared to return a leaf type.
-       */
-      if (x.isNative()) {
-        return;
-      }
-
       if (!(x.getType() instanceof JReferenceType)) {
         return;
       }
@@ -523,6 +513,20 @@
         return;
       }
 
+      JClassType concreteType = getSingleConcreteType(x.getType());
+      if (concreteType != null) {
+        x.setType(concreteType);
+        myDidChange = true;
+      }
+
+      /*
+       * The only information that we can infer about native methods is if they
+       * are declared to return a leaf type.
+       */
+      if (x.isNative()) {
+        return;
+      }
+
       // tighten based on both returned types and possible overrides
       List<JReferenceType> typeList = new ArrayList<JReferenceType>();
 
@@ -614,7 +618,10 @@
       if (type instanceof JReferenceType) {
         JReferenceType refType = (JReferenceType) type;
         if (refType.isAbstract()) {
-          return getSingleConcrete((JReferenceType) type, implementors);
+          JClassType singleConcrete = getSingleConcrete((JReferenceType) type,
+              implementors);
+          assert (singleConcrete == null || program.typeOracle.isInstantiatedType(singleConcrete));
+          return singleConcrete;
         }
       }
       return null;
@@ -633,17 +640,17 @@
         return;
       }
 
-      // tighten based on leaf types
-      JClassType leafType = getSingleConcreteType(refType);
-      if (leafType != null) {
-        x.setType(leafType);
+      // tighten based on non-instantiability
+      if (!program.typeOracle.isInstantiatedType(refType)) {
+        x.setType(typeNull);
         myDidChange = true;
         return;
       }
 
-      // tighten based on non-instantiability
-      if (!program.typeOracle.isInstantiatedType(refType)) {
-        x.setType(typeNull);
+      // tighten based on leaf types
+      JClassType leafType = getSingleConcreteType(refType);
+      if (leafType != null) {
+        x.setType(leafType);
         myDidChange = true;
         return;
       }