Incremental compilation: set up inheritance.

dart/pkg/compiler/lib/src/world.dart

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 part of dart2js;
 
 abstract class ClassWorld {
   // TODO(johnniwinther): Refine this into a `BackendClasses` interface.
   Backend get backend;
 
@@ skipping 78 matching lines @@
   /// Returns `true` if any live class that mixes in [cls] implements [type].
   bool hasAnySubclassOfMixinUseThatImplements(ClassElement cls,
                                               ClassElement type);
 
   /// Returns `true` if any live class that mixes in [mixin] is also a subclass
   /// of [superclass].
   bool hasAnySubclassThatMixes(ClassElement superclass, ClassElement mixin);
 
   /// Returns `true` if any subclass of [superclass] implements [type].
   bool hasAnySubclassThatImplements(ClassElement superclass, ClassElement type);
+
+  bool get hasClosedWorldAssumption;

[Johnni Winther, 2014/11/14 10:20:53]

Document what this implies.

As I read the use it seem to be more like 'canUseClosedWorldAssumption' in which
case the value is `!compiler.hasIncrementalSupport`.

[ahe, 2014/11/14 14:40:05]

I got this wrong. The return value should have been negated, and the use should
be negated.

 }
 
 class World implements ClassWorld {
   ClassElement get objectClass => compiler.objectClass;
   ClassElement get functionClass => compiler.functionClass;
   ClassElement get boolClass => compiler.boolClass;
   ClassElement get numClass => compiler.numClass;
   ClassElement get intClass => compiler.intClass;
   ClassElement get doubleClass => compiler.doubleClass;
   ClassElement get stringClass => compiler.stringClass;
@@ skipping 405 matching lines @@
     // type inference ran. This is currently only the case for the call
     // method of function classes that were generated for function
     // expressions. In such a case, we have to look at the original
     // function expressions's element.
     // TODO(herhut): Generate classes for function expressions earlier.
     if (element is closureMapping.SynthesizedCallMethodElementX) {
       return getMightBePassedToApply(element.expression);
     }
     return functionsThatMightBePassedToApply.contains(element);
   }
+
+  bool get hasClosedWorldAssumption => compiler.hasIncrementalSupport;
 }