outputFile.text == originalOutput
    }

    private withAnnotatedType(String typeName) {
        sourceFile "my/${typeName}.java", """
            package my;

            import org.gradle.internal.instrumentation.api.annotations.*;

            @SpecificJvmCallInterceptors(generatedClassName = "my.Interceptors")
            class $typeName {
                @InterceptCalls

    }

    private static boolean isNullableCtAnnotation(Object ann) {
        if (Proxy.isProxyClass(ann.class)) {
            def typeName = (Proxy.getInvocationHandler(ann) as AnnotationImpl).annotation.typeName
            return NULLABLE_ANNOTATIONS.any { it.name == typeName }
        }
        return false
    }

    TypeValidationDataSpec pluginId(String pluginId);
    TypeValidationDataSpec propertyName(String propertyName);
    TypeValidationDataSpec parentPropertyName(String parentPropertyName);
    TypeValidationDataSpec typeName(String typeName);

)

func TestIsAlias(t *testing.T) {
	check := func(obj *TypeName, want bool) {
		if got := obj.IsAlias(); got != want {
			t.Errorf("%v: got IsAlias = %v; want %v", obj, got, want)
		}
	}

	// predeclared types
	check(Unsafe.Scope().Lookup("Pointer").(*TypeName), false)
	for _, name := range Universe.Names() {
		if obj, _ := Universe.Lookup(name).(*TypeName); obj != nil {

    }

    GradleLazyType(Type type) {
        this.type = type;
    }

    public Type asType() {
        return type;
    }

    public TypeName asTypeName() {
        return TypeUtils.typeName(type);
    }

    public static boolean isAnyOf(Type type) {
        for (GradleLazyType gradleType : values()) {
            if (gradleType.type != null && gradleType.type.equals(type)) {

// constraint is non-nil, it must be fully defined.
func NewTypeParam(obj *TypeName, constraint Type) *TypeParam {
	return (*Checker)(nil).newTypeParam(obj, constraint)
}

// check may be nil
func (check *Checker) newTypeParam(obj *TypeName, constraint Type) *TypeParam {
	// Always increment lastID, even if it is not used.
	id := nextID()
	if check != nil {
		check.nextID++

		return m
	case types.TypeType:
		return m.typeValue
	}
	return types.NewErr("disallowed conversion from %q to %q", m.typeValue.TypeName(), typeVal.TypeName())
}

// Equal returns true if the other object is the same pointer-wise.
func (m *MapValue) Equal(other ref.Val) ref.Val {
	otherMap, ok := other.(*MapValue)
	if !ok {
		return types.MaybeNoSuchOverloadErr(other)
	}
	return types.Bool(m == otherMap)
}

		cl := n.(*ast.CompositeLit)

		typ := pass.TypesInfo.Types[cl].Type
		if typ == nil {
			// cannot determine composite literals' type, skip it
			return
		}
		typeName := typ.String()
		if whitelist && unkeyedLiteral[typeName] {
			// skip whitelisted types
			return
		}
		var structuralTypes []types.Type
		switch typ := aliases.Unalias(typ).(type) {
		case *types.TypeParam:

}

func dumpBlocks(bs []md.Block, depth int) {
	for _, b := range bs {
		dumpBlock(b, depth)
	}
}

func dumpBlock(b md.Block, depth int) {
	typeName := strings.TrimPrefix(fmt.Sprintf("%T", b), "*markdown.")
	dprintf(depth, "%s\n", typeName)
	switch b := b.(type) {
	case *md.Paragraph:
		dumpInlines(b.Text.Inline, depth+1)
	case *md.Heading:
		dumpInlines(b.Text.Inline, depth+1)
	case *md.List:

#if GTEST_OS_SYMBIAN
  // Streams a value (either a pointer or not) to this object.
  template <typename T>
  inline Message& operator <<(const T& value) {
    StreamHelper(typename internal::is_pointer<T>::type(), value);
    return *this;
  }
#else
  // Streams a non-pointer value to this object.
  template <typename T>
  inline Message& operator <<(const T& val) {
    // Some libraries overload << for STL containers.  These