anchor.diff:  
     @override
     InterfaceType get deprecatedType {
  -    assert(_coreLibrary != null);
       _deprecatedType ??= _getType(_coreLibrary, "Deprecated");
       return _deprecatedType;
     }
   
     @override
     InterfaceType get doubleType {
  -    assert(_coreLibrary != null);
       _doubleType ??= _getType(_coreLibrary, "double");
       return _doubleType;
     }
  
positive.code: 
    @override
    InterfaceType get functionType {
      assert(_coreLibrary != null);
      _functionType ??= _getType(_coreLibrary, "Function");
      return _functionType;
    }
  
    @override
    InterfaceType get futureDynamicType {
      assert(_asyncLibrary != null);
      _futureDynamicType ??= futureType.instantiate(<DartType>[dynamicType]);
      return _futureDynamicType;
    }
  
    @override
    InterfaceType get futureNullType {
      assert(_asyncLibrary != null);
      _futureNullType ??= futureType.instantiate(<DartType>[nullType]);
      return _futureNullType;
    }
  
    @override
    InterfaceType get futureOrNullType {
      assert(_asyncLibrary != null);
      _futureOrNullType ??= futureOrType.instantiate(<DartType>[nullType]);
      return _futureOrNullType;
    }
  
    @override
    InterfaceType get futureOrType {
      assert(_asyncLibrary != null);
      _futureOrType ??= _getType(_asyncLibrary, "FutureOr");
      return _futureOrType;
    }
  
    @override
    InterfaceType get futureType {
      assert(_asyncLibrary != null);
      _futureType ??= _getType(_asyncLibrary, "Future");
      return _futureType;
    }
  
    @override
    InterfaceType get intType {
      assert(_coreLibrary != null);
      _intType ??= _getType(_coreLibrary, "int");
      return _intType;
    }
  
    @override
    InterfaceType get iterableDynamicType {
      assert(_coreLibrary != null);
      _iterableDynamicType ??= iterableType.instantiate(<DartType>[dynamicType]);
      return _iterableDynamicType;
    }
  
    @override
    InterfaceType get iterableObjectType {
      assert(_coreLibrary != null);
      _iterableObjectType ??= iterableType.instantiate(<DartType>[objectType]);
      return _iterableObjectType;
    }
  
    @override
    InterfaceType get iterableType {
      assert(_coreLibrary != null);
      _iterableType ??= _getType(_coreLibrary, "Iterable");
      return _iterableType;
    }
  
    @override
    InterfaceType get listType {
      assert(_coreLibrary != null);
      _listType ??= _getType(_coreLibrary, "List");
      return _listType;
    }
  
    @override
    InterfaceType get mapObjectObjectType {
      assert(_coreLibrary != null);
      return _mapObjectObjectType ??=
          mapType.instantiate(<DartType>[objectType, objectType]);
    }
  
    @override
    InterfaceType get mapType {
      assert(_coreLibrary != null);
      _mapType ??= _getType(_coreLibrary, "Map");
      return _mapType;
    }
  
negative.code: 
    @override
    InterfaceType get nullType {
      _nullType ??= _getType(_coreLibrary, "Null");
      return _nullType;
    }
  
    @override
    InterfaceType get numType {
      _numType ??= _getType(_coreLibrary, "num");
      return _numType;
    }
  
    @override
    InterfaceType get objectType {
      _objectType ??= _getType(_coreLibrary, "Object");
      return _objectType;
    }
  
    @override
    InterfaceType get setType {
      return _setType ??= _getType(_coreLibrary, "Set");
    }
  
    @override
    InterfaceType get stackTraceType {
      _stackTraceType ??= _getType(_coreLibrary, "StackTrace");
      return _stackTraceType;
    }
  
    @override
    InterfaceType get streamDynamicType {
      _streamDynamicType ??= streamType.instantiate(<DartType>[dynamicType]);
      return _streamDynamicType;
    }
  
    @override
    InterfaceType get streamType {
      _streamType ??= _getType(_asyncLibrary, "Stream");
      return _streamType;
    }
  
    @override
    InterfaceType get stringType {
      _stringType ??= _getType(_coreLibrary, "String");
      return _stringType;
    }
  
    @override
    InterfaceType get symbolType {
      _symbolType ??= _getType(_coreLibrary, "Symbol");
      return _symbolType;
    }
  
    @override
    InterfaceType get typeType {
      _typeType ??= _getType(_coreLibrary, "Type");
      return _typeType;
    }
  