anchor.diff:      linkedData?.read(this);
       if (_type != null) return _type!;
   
  -    if (linkedNode != null) {
  -      // While performing inference during linking, the first step is to collect
  -      // dependencies. During this step we resolve the expression, but we might
  -      // reference elements that don't have their types inferred yet. So, here
  -      // we give some type. A better solution would be to infer recursively, but
  -      // we are not doing this yet.
  -      if (_type == null) {
  -        assert(linkedContext!.isLinking);
  -        return DynamicTypeImpl.instance;
  -      }
  -
  -      return _type!;
  -    }
       if (isSynthetic && _type == null) {
         if (getter != null) {
           _type = getter!.returnType;
  
positive.code: 
    @override
    bool get isLate {
      if (linkedNode != null) {
        return enclosingUnit.linkedContext!.isLate(linkedNode!);
      }
      return hasModifier(Modifier.LATE);
    }
  
  
negative.code:   ExecutableElementImpl(String name, int offset, {Reference? reference})
        : super(name, offset, reference: reference);
  
    @override
    Element get enclosingElement => super.enclosingElement!;
  
    @override
    bool get hasImplicitReturnType {
      return hasModifier(Modifier.IMPLICIT_TYPE);
    }
  
  