anchor.diff:      }
     }
   
  -  /**
  -   * @return `true` if given [Type] implements operator <i>==</i>, and it is not
  -   *         <i>int</i> or <i>String</i>.
  -   */
  +  /// @return `true` if given [Type] implements operator <i>==</i>, and it is
  +  ///         not <i>int</i> or <i>String</i>.
     bool _implementsEqualsWhenNotAllowed(DartType type) {
       // ignore int or String
       if (type == null || type == _intType || type == _typeProvider.stringType) {
  
positive.code:     }
    }
  
    /**
     * Return the implicit label scope in which the current node is being
     * resolved.
     */
    ImplicitLabelScope get implicitLabelScope => _implicitLabelScope;
  
    /**
     * Replaces the current [Scope] with the enclosing [Scope].
     *
     * @return the enclosing [Scope].
     */
    Scope popNameScope() {
      nameScope = nameScope.enclosingScope;
      return nameScope;
    }
  
    /**
     * Pushes a new [Scope] into the visitor.
     *
     * @return the new [Scope].
     */
    Scope pushNameScope() {
      Scope newScope = new EnclosedScope(nameScope);
      nameScope = newScope;
  
negative.code:     return typeProvider.futureOrType.instantiate([type]);
    }
  
    /// The given expression is the expression used to compute the iterator for a
    /// for-each statement. Attempt to compute the type of objects that will be
    /// assigned to the loop variable and return that type. Return `null` if the
    /// type could not be determined. The [iteratorExpression] is the expression
    /// that will return the Iterable being iterated over.
    DartType _getIteratorElementType(Expression iteratorExpression) {
      DartType expressionType = iteratorExpression.staticType;
      if (expressionType is InterfaceType) {
  