Merge "Remove usage of inBody boolean into UsageFinder" into ub-jack

2 files changed, 53 insertions, 41 deletions

diff --git a/jack/src/com/android/jack/experimental/incremental/CompilerState.java b/jack/src/com/android/jack/experimental/incremental/CompilerState.java
index 9a79f45..4f31883 100644
--- a/jack/src/com/android/jack/experimental/incremental/CompilerState.java
+++ b/jack/src/com/android/jack/experimental/incremental/CompilerState.java
@@ -63,7 +63,7 @@ public final class CompilerState {
   private Map<String, Set<String>> codeFileToUsedFiles = new HashMap<String, Set<String>>();
 
   @Nonnull
-  private Map<String, Set<String>> structFileToUsedFiles = new HashMap<String, Set<String>>();
+  private Map<String, Set<String>> hierarchyFileToUsedFiles = new HashMap<String, Set<String>>();
 
   @Nonnull
   private Map<String, Set<String>> cstFileToUsedFiles = new HashMap<String, Set<String>>();
@@ -89,14 +89,14 @@ public final class CompilerState {
     for (String javaFileToDelete : filesToDelete) {
       javaFileToTypeNamePath.remove(javaFileToDelete);
       codeFileToUsedFiles.remove(javaFileToDelete);
-      structFileToUsedFiles.remove(javaFileToDelete);
+      hierarchyFileToUsedFiles.remove(javaFileToDelete);
       cstFileToUsedFiles.remove(javaFileToDelete);
     }
 
     for (String javaFileToRecompile : filesToRecompile) {
       javaFileToTypeNamePath.remove(javaFileToRecompile);
       codeFileToUsedFiles.remove(javaFileToRecompile);
-      structFileToUsedFiles.remove(javaFileToRecompile);
+      hierarchyFileToUsedFiles.remove(javaFileToRecompile);
       cstFileToUsedFiles.remove(javaFileToRecompile);
     }
   }
@@ -120,8 +120,8 @@ public final class CompilerState {
     getOrCreate(javaFileToTypeNamePath, javaFileName).add(typeName);
   }
 
-  public void addStructUsage(@Nonnull String filename, @CheckForNull String nameOfUsedFile) {
-    addUsage(structFileToUsedFiles, filename, nameOfUsedFile);
+  public void addHierarchyUsage(@Nonnull String filename, @CheckForNull String nameOfUsedFile) {
+    addUsage(hierarchyFileToUsedFiles, filename, nameOfUsedFile);
   }
 
   public void addCstUsage(@Nonnull String filename, @CheckForNull String nameOfUsedFile) {
@@ -147,7 +147,7 @@ public final class CompilerState {
       writeMap(sb, javaFileToTypeNamePath);
       writeMap(sb, codeFileToUsedFiles);
       writeMap(sb, cstFileToUsedFiles);
-      writeMap(sb, structFileToUsedFiles);
+      writeMap(sb, hierarchyFileToUsedFiles);
 
       ps = new PrintStream(compilerStateFile.openWrite());
       ps.print(sb.toString());
@@ -173,7 +173,7 @@ public final class CompilerState {
       javaFileToTypeNamePath = readMap(br);
       codeFileToUsedFiles = readMap(br);
       cstFileToUsedFiles = readMap(br);
-      structFileToUsedFiles = readMap(br);
+      hierarchyFileToUsedFiles = readMap(br);
     } catch (IOException e) {
       throw new JackIOException(
           "Could not read compiler state file '" + csf.getPath() + "'", e);
@@ -196,7 +196,8 @@ public final class CompilerState {
     for (String fileName : codeFileToUsedFiles.keySet()) {
       getOrCreate(fileDependencies, fileName);
 
-      computeStructDependencies(fileDependencies, structFileToUsedFiles.get(fileName), fileName);
+      computeHierarchyDependencies(fileDependencies, hierarchyFileToUsedFiles.get(fileName),
+          fileName);
       computeCstDependencies(fileDependencies, cstFileToUsedFiles.get(fileName), fileName,
           new HashSet<String>());
       computeCodeDependencies(fileDependencies, codeFileToUsedFiles.get(fileName), fileName);
@@ -237,12 +238,12 @@ public final class CompilerState {
       builder.append(TextUtils.LINE_SEPARATOR);
     }
 
-    builder.append("*Struct usage list*");
+    builder.append("*Hierarchy usage list*");
     builder.append(TextUtils.LINE_SEPARATOR);
-    for (String fileName : structFileToUsedFiles.keySet()) {
+    for (String fileName : hierarchyFileToUsedFiles.keySet()) {
       builder.append(fileName);
       builder.append("->");
-      builder.append(structFileToUsedFiles.get(fileName));
+      builder.append(hierarchyFileToUsedFiles.get(fileName));
       builder.append(TextUtils.LINE_SEPARATOR);
     }
 
@@ -255,8 +256,8 @@ public final class CompilerState {
       Set<String> usedByFiles = getOrCreate(fileDependencies, codeDependency);
       usedByFiles.add(dependencyToAdd);
 
-      if (structFileToUsedFiles.get(codeDependency) != null) {
-        computeStructDependencies(fileDependencies, structFileToUsedFiles.get(codeDependency),
+      if (hierarchyFileToUsedFiles.get(codeDependency) != null) {
+        computeHierarchyDependencies(fileDependencies, hierarchyFileToUsedFiles.get(codeDependency),
             dependencyToAdd);
       }
     }
@@ -278,15 +279,15 @@ public final class CompilerState {
     }
   }
 
-  private void computeStructDependencies(@Nonnull Map<String, Set<String>> fileDependencies,
-      @Nonnull Set<String> structDependencies, @Nonnull String dependencyToAdd) {
-    for (String structDependency : structDependencies) {
-      Set<String> usedByFiles = getOrCreate(fileDependencies, structDependency);
+  private void computeHierarchyDependencies(@Nonnull Map<String, Set<String>> fileDependencies,
+      @Nonnull Set<String> hierarchyDependencies, @Nonnull String dependencyToAdd) {
+    for (String hierarchyDependency : hierarchyDependencies) {
+      Set<String> usedByFiles = getOrCreate(fileDependencies, hierarchyDependency);
       usedByFiles.add(dependencyToAdd);
 
-      Set<String> newStructDependencies = structFileToUsedFiles.get(structDependency);
-      if (newStructDependencies != null) {
-        computeStructDependencies(fileDependencies, newStructDependencies, dependencyToAdd);
+      Set<String> newHierarchyDependencies = hierarchyFileToUsedFiles.get(hierarchyDependency);
+      if (newHierarchyDependencies != null) {
+        computeHierarchyDependencies(fileDependencies, newHierarchyDependencies, dependencyToAdd);
       }
     }
   }
diff --git a/jack/src/com/android/jack/experimental/incremental/UsageFinder.java b/jack/src/com/android/jack/experimental/incremental/UsageFinder.java
index da8d381..07e17ac 100644
--- a/jack/src/com/android/jack/experimental/incremental/UsageFinder.java
+++ b/jack/src/com/android/jack/experimental/incremental/UsageFinder.java
@@ -18,8 +18,10 @@ package com.android.jack.experimental.incremental;
 
 import com.android.jack.backend.dex.TypeReferenceCollector;
 import com.android.jack.ir.ast.JArrayType;
+import com.android.jack.ir.ast.JClass;
+import com.android.jack.ir.ast.JDefinedClass;
 import com.android.jack.ir.ast.JDefinedClassOrInterface;
-import com.android.jack.ir.ast.JMethodBody;
+import com.android.jack.ir.ast.JInterface;
 import com.android.jack.ir.ast.JType;
 import com.android.jack.ir.sourceinfo.SourceInfo;
 import com.android.sched.item.Description;
@@ -28,6 +30,7 @@ import com.android.sched.item.Synchronized;
 import com.android.sched.schedulable.RunnableSchedulable;
 import com.android.sched.schedulable.Transform;
 
+import javax.annotation.CheckForNull;
 import javax.annotation.Nonnull;
 
 /**
@@ -47,27 +50,32 @@ public class UsageFinder implements RunnableSchedulable<JDefinedClassOrInterface
     @Nonnull
     private final String currentFileName;
 
-    private boolean inBody = false;
-
     public Visitor(@Nonnull JType currentType, @Nonnull CompilerState compilerState) {
       this.compilerState = compilerState;
       assert currentType.getSourceInfo() != SourceInfo.UNKNOWN;
       currentFileName = currentType.getSourceInfo().getFileName();
       compilerState.addCodeUsage(currentFileName, null);
       compilerState.addCstUsage(currentFileName, null);
-      compilerState.addStructUsage(currentFileName, null);
-    }
+      compilerState.addHierarchyUsage(currentFileName, null);
 
-    @Override
-    public boolean visit(@Nonnull JMethodBody x) {
-      inBody = true;
-      return super.visit(x);
-    }
+      if (currentType instanceof JDefinedClassOrInterface) {
+        if (currentType instanceof JDefinedClass) {
+          JClass superClass = ((JDefinedClass) currentType).getSuperClass();
+          if (superClass != null) {
+            String usedTypeFileName = getFileName(superClass);
+            if (usedTypeFileName != null) {
+              compilerState.addHierarchyUsage(currentFileName, usedTypeFileName);
+            }
+          }
+        }
 
-    @Override
-    public void endVisit(@Nonnull JMethodBody x) {
-      super.endVisit(x);
-      inBody = false;
+        for (JInterface interf : ((JDefinedClassOrInterface) currentType).getImplements()) {
+          String usedTypeFileName = getFileName(interf);
+          if (usedTypeFileName != null) {
+            compilerState.addHierarchyUsage(currentFileName, usedTypeFileName);
+          }
+        }
+      }
     }
 
     @Override
@@ -75,16 +83,19 @@ public class UsageFinder implements RunnableSchedulable<JDefinedClassOrInterface
       if (usedType instanceof JArrayType) {
         usedType = ((JArrayType) usedType).getLeafType();
       }
-      if (usedType.getSourceInfo() == SourceInfo.UNKNOWN) {
-        return;
-      }
-      String usedTypeFileName = usedType.getSourceInfo().getFileName();
-      if (inBody) {
+      String usedTypeFileName = getFileName(usedType);
+      if (usedTypeFileName != null) {
         compilerState.addCodeUsage(currentFileName, usedTypeFileName);
-      } else {
-        compilerState.addStructUsage(currentFileName, usedTypeFileName);
       }
     }
+
+    @CheckForNull
+    private String getFileName(@Nonnull JType usedType) {
+      if (usedType.getSourceInfo() == SourceInfo.UNKNOWN) {
+        return null;
+      }
+      return (usedType.getSourceInfo().getFileName());
+    }
   }
 
   @Override