anchor.diff:    @override
     CompilationUnitElement get enclosingElement =>
         super.enclosingElement as CompilationUnitElement;
  -
  -  @override
  -  TypeParameterizedElementMixin get enclosingTypeParameterContext => null;
   
     @override
     CompilationUnitElementImpl get enclosingUnit =>
  
positive.code: 
      return _typeParameterElements ?? const <TypeParameterElement>[];
    }
  
    /// Get a list of [TypeParameterType] objects corresponding to the
    /// element's type parameters.
    List<TypeParameterType> get typeParameterTypes {
      return _typeParameterTypes ??= typeParameters
          .map((TypeParameterElement e) =>
              e.instantiate(nullabilitySuffix: NullabilitySuffix.star))
          .toList(growable: false);
    }
  
    @override
    int computeDeBruijnIndex(TypeParameterElement typeParameter,
        {int offset = 0}) {
      if (typeParameter.enclosingElement == this) {
        var index = typeParameters.indexOf(typeParameter);
        assert(index >= 0);
        return typeParameters.length - index + offset;
      } else if (enclosingTypeParameterContext != null) {
        return enclosingTypeParameterContext.computeDeBruijnIndex(typeParameter,
            offset: offset + typeParameters.length);
      } else {
        return null;
      }
    }
  
    /// Convert the given [index] into a type parameter type.
    TypeParameterType getTypeParameterType(int index) {
      List<TypeParameterType> types = typeParameterTypes;
      if (index <= types.length) {
        return types[types.length - index];
      } else if (enclosingTypeParameterContext != null) {
        return enclosingTypeParameterContext
            .getTypeParameterType(index - types.length);
      } else {
        // If we get here, it means that a summary contained a type parameter
        // index that was out of range.
        throw new RangeError('Invalid type parameter index');
      }
    }
  }
  
  /// Interface used by linker serialization methods to convert type parameter
  /// references into De Bruijn indices.
  abstract class TypeParameterSerializationContext {
    /// Return the given [typeParameter]'s de Bruijn index in this context, or
    /// `null` if it's not in scope.
    ///
    /// If an [offset] is provided, then it is added to the computed index.
    int computeDeBruijnIndex(TypeParameterElement typeParameter, {int offset: 0});
  }
  
  /// Container with information about explicit top-level property accessors and
  
negative.code:   }
  
    @override
    String get identifier {
      String identifier = super.identifier;
      Element enclosing = this.enclosingElement;
  