Refine code documentation

Author: liufengyun

compiler/src/dotty/tools/dotc/transform/init/Checking.scala

@@ -37,9 +37,9 @@ object Checking {
     fieldsInited: mutable.Set[Symbol],
     parentsInited: mutable.Set[ClassSymbol],
     safePromoted: mutable.Set[Potential],      // Potentials that can be safely promoted
-    dependencies: mutable.Set[Dependency],     // if the current class is a static object, its dependencies
+    dependencies: mutable.Set[Dependency],     // dependencies collected for checking global objects
     env: Env,
-    init: Boolean = false                      // whether object is initialized, used in CycleChecker
+    init: Boolean = false                      // whether the object is initialized, used in CycleChecker
   ) {
     def withOwner[T](sym: Symbol)(op: State ?=> T): T =
       val state = this.copy(env = env.withOwner(sym))

compiler/src/dotty/tools/dotc/transform/init/CycleChecker.scala

@@ -24,10 +24,10 @@ import scala.collection.mutable
  *  For the check to be simple and fast, the algorithm uses a combination of
  *  coarse-grained analysis and fine-grained analysis.
  *
- *  Fine-grained abstractions are created from the initialization
+ *  Fine-grained dependencies are collected from the initialization
  *  check for static objects.
  *
- *  Coarse-grained abstractions are created as follows:
+ *  Coarse-grained dependencies are created as follows:
  *
  *  - if a static object `O` is used in another class/static-object `B`,
  *    then B -> O
@@ -374,6 +374,7 @@ class CycleChecker(cache: Cache) {
 
   def clean() = {
     summaryCache.clear()
+    proxyCache.clear()
     classesInCurrentRun.clear()
     objectsInCurrentRun.clear()
   }