anchor.diff:    bool get isBottom => true;
   
     @override
  -  NullabilitySuffix get nullabilitySuffix => NullabilitySuffix.none;
  +  bool get isDartCoreNull {
  +    // `Never?` is equivalent to `Null`, so make sure it behaves the same.
  +    return nullabilitySuffix == NullabilitySuffix.question;
  +  }
   
     @override
     bool operator ==(Object object) => identical(object, this);
  
positive.code: 
    @override
    TypeImpl withNullability(NullabilitySuffix nullabilitySuffix) {
      // The bottom type is always non-nullable.
      return this;
    }
  }
  
  
negative.code:  */
  class BottomTypeImpl extends TypeImpl {
    /**
     * The unique instance of this class, nullable.
     *
     * This behaves equivalently to the `Null` type, but we distinguish it for two
     * reasons: (1) there are circumstances where we need access to this type, but
     * we don't have access to the type provider, so using `Never?` is a
     * convenient solution.  (2) we may decide that the distinction is convenient
     * in diagnostic messages (this is TBD).
     */
    static final BottomTypeImpl instanceNullable =
        new BottomTypeImpl._(NullabilitySuffix.question);
  
    /**
     * The unique instance of this class, non-nullable.
     */
    static final BottomTypeImpl instance =
        new BottomTypeImpl._(NullabilitySuffix.none);
  
    @override
    final NullabilitySuffix nullabilitySuffix;
  
    /**
     * Prevent the creation of instances of this class.
     */
    BottomTypeImpl._(this.nullabilitySuffix)
        : super(new NeverElementImpl(), "Never") {
      (element as NeverElementImpl).type = this;
    }
  
  