./staging/src/k8s.io/api/apps/v1beta1/types.go
./staging/src/k8s.io/api/apps/v1beta2/types.go
./staging/src/k8s.io/api/autoscaling/v2beta2/types.go
./staging/src/k8s.io/api/certificates/v1/types.go
./staging/src/k8s.io/api/certificates/v1beta1/types.go
./staging/src/k8s.io/api/core/v1/types.go
./staging/src/k8s.io/api/networking/v1/types.go

		vtypes, err := structuralTypes(V)
		if err != nil {
			return // invalid type
		}

		var V0 types.Type // integral type in the type set of V

		for _, vt := range vtypes {
			u, _ := vt.Underlying().(*types.Basic)
			if u != nil && u.Info()&types.IsInteger != 0 {
				switch u.Kind() {
				case types.Byte, types.Rune, types.UntypedRune:
					continue
				}
				V0 = vt
				break
			}
		}

		return
	}

	switch t.Kind() {
	case types.TPTR, types.TUNSAFEPTR, types.TFUNC, types.TCHAN, types.TMAP:
		if off&int64(types.PtrSize-1) != 0 {
			base.Fatalf("typebits.Set: invalid alignment, %v", t)
		}
		bv.Set(int32(off / int64(types.PtrSize))) // pointer

	case types.TSTRING:
		// struct { byte *str; intgo len; }
		if off&int64(types.PtrSize-1) != 0 {
			base.Fatalf("typebits.Set: invalid alignment, %v", t)
		}

import javax.annotation.Nullable

class TypesTest extends Specification {
    def "base object types are not visited"() {
        when: Types.walkTypeHierarchy(Object, Mock(Types.TypeVisitor))
        then: 0 * _

        when: Types.walkTypeHierarchy(GroovyObject, [Object, GroovyObject], Mock(Types.TypeVisitor))
        then: 0 * _
    }

    class Base {
        @Incubating

//
// See the documentation of StructuralTerms for more information on
// normalization.
func UnionTermSet(union *types.Union) ([]*types.Term, error) {
	return computeTermSet(union)
}

func computeTermSet(typ types.Type) ([]*types.Term, error) {
	tset, err := computeTermSetInternal(typ, make(map[types.Type]*termSet), 0)
	if err != nil {
		return nil, err
	}
	if tset.terms.isEmpty() {
		return nil, ErrEmptyTypeSet
	}

  }

  @Test
  @TestMetadata("ListAlias.kt")
  public void testListAlias() {
    runTest("analysis/analysis-api/testData/types/abbreviatedType/ListAlias.kt");
  }

  @Test
  @TestMetadata("ListAliasFromLibrary.kt")
  public void testListAliasFromLibrary() {
    runTest("analysis/analysis-api/testData/types/abbreviatedType/ListAliasFromLibrary.kt");

	q.Enqueue(types.UID("foo1"), -1*time.Minute)
	q.Enqueue(types.UID("foo2"), -1*time.Minute)
	q.Enqueue(types.UID("foo3"), 1*time.Minute)
	q.Enqueue(types.UID("foo4"), 1*time.Minute)
	expected := []types.UID{types.UID("foo1"), types.UID("foo2")}
	compareResults(t, expected, q.GetWork())
	compareResults(t, []types.UID{}, q.GetWork())
	// Dial the time to 1 hour ahead.
	clock.Step(time.Hour)
	expected = []types.UID{types.UID("foo3"), types.UID("foo4")}

			types.NewField(base.Pos, typecheck.Lookup("c"), types.Types[types.TUNSAFEPTR]),
			types.NewField(base.Pos, typecheck.Lookup("elem"), types.Types[types.TUNSAFEPTR]),
		}))
	}
	return scase

var x3 = b && b2    // ERROR "mismatched types B and B2|incompatible types"
var x4 = x1 && b2   // ERROR "mismatched types B and B2|incompatible types"
var x5 = x2 && b2   // ERROR "mismatched types B and B2|incompatible types"
var x6 = b2 && x1   // ERROR "mismatched types B2 and B|incompatible types"
var x7 = b2 && x2   // ERROR "mismatched types B2 and B|incompatible types"

        expect:
        def types = inspector.getReachableTypes(Thing)
        types == [Thing, SuperThing, GenericThing, Item1, Item2, Item3, Item4, Item5, Runnable, List, Map, Set] as Set

        def types2 = inspector.getReachableTypes(Thing)
        types2.is(types)
    }

    def "inspects cyclic types"() {
        expect:
        def types = inspector.getReachableTypes(Parent)