anchor.diff:      //      }
       //    }
       //  }
  -    final CoreTypes coreTypes = typeContext.typeEnvironment.coreTypes;
  +    //
  +    // and:
  +    //
  +    //   await for ({var/final} T <variable> in <stream>) { ... }
  +    //
  +    // Into
  +    //
  +    //  {
  +    //    final StreamIterator<T> #forIterator = StreamIterator(<stream>);
  +    //    for (; await #forIterator.moveNext() ;) {
  +    //        {var/final} T variable = await #forIterator.current;
  +    //        ...
  +    //      }
  +    //    }
  +    //  }
   
       // The CFE might invoke this transformation despite the program having
       // compile-time errors. So we will not transform this [stmt] if the
  
positive.code:           InvalidExpression('Invalid iterable type in for-in'));
      }
  
      final DartType elementType = stmt.getElementType(typeContext);
      final iteratorType = InterfaceType(
          coreTypes.iteratorClass, Nullability.nonNullable, [elementType]);
  
      final iterator = VariableDeclaration("#forIterator",
          initializer: InstanceGet(
              InstanceAccessKind.Instance, iterable, Name('iterator'),
              interfaceTarget: coreTypes.iterableGetIterator,
              resultType: iteratorType)
            ..fileOffset = iterable.fileOffset,
          type: iteratorType)
        ..fileOffset = iterable.fileOffset;
  
      final condition = InstanceInvocation(InstanceAccessKind.Instance,
          VariableGet(iterator), Name('moveNext'), Arguments(const []),
          interfaceTarget: coreTypes.iteratorMoveNext,
          functionType: coreTypes.iteratorMoveNext.getterType as FunctionType)
        ..fileOffset = iterable.fileOffset;
  
      final variable = stmt.variable
        ..initializer = (InstanceGet(
            InstanceAccessKind.Instance, VariableGet(iterator), Name('current'),
            interfaceTarget: coreTypes.iteratorGetCurrent,
            resultType: elementType)
          ..fileOffset = stmt.bodyOffset);
  
      final Block body = Block([variable, stmt.body])
        ..fileOffset = stmt.fileOffset;
  
      return Block([iterator, ForStatement(const [], condition, const [], body)])
          .accept<TreeNode>(this);
    }
  }
  
negative.code:     return super.visitClass(cls);
    }
  
    TreeNode _lowerForIn(ForInStatement stmt) {
      // Transform
      //
      //   for ({var/final} T <variable> in <iterable>) { ... }
  