import org.jetbrains.kotlin.analysis.api.descriptors.types.KaFe10ClassErrorType
import org.jetbrains.kotlin.analysis.api.descriptors.types.KaFe10UsualClassType
import org.jetbrains.kotlin.analysis.api.descriptors.types.base.KaFe10Type
import org.jetbrains.kotlin.analysis.api.lifetime.KaLifetimeToken
import org.jetbrains.kotlin.analysis.api.types.KaStarTypeProjection
import org.jetbrains.kotlin.analysis.api.types.KaType

	_ = len(x.slice) || x == nil // ERROR "invalid operation: .+ \(operator \|\| not defined on int\)|incompatible types|mismatched types int and untyped bool"
	_ = x == nil && len(x.slice) // ERROR "invalid operation: .+ \(operator && not defined on int\)|incompatible types|mismatched types untyped bool and int"

	_ = "" + i   // ERROR "invalid operation.*mismatched types.*untyped string and int"
	_ = "" + nil // ERROR "invalid operation.*mismatched types.*untyped string and nil|(untyped nil)"
)

var (
	_ = s + false // ERROR "invalid operation.*mismatched types.*string and untyped bool"
	_ = s + 1     // ERROR "invalid operation.*mismatched types.*string and untyped int"

				switch size := v.Aux.(*types.Type).Size(); size {
				case 4:
					v.Aux = f.Config.Types.UInt32
				case 8:
					v.Aux = f.Config.Types.UInt64
					newInt64 = true
				default:
					v.Fatalf("bad float type with size %d", size)
				}
			}
		}
	}

	if newInt64 && f.Config.RegSize == 4 {

	case *ast.Ident:
		switch t.Name {
		case "byte":
			return "types.ByteType"
		case "rune":
			return "types.RuneType"
		}
		return fmt.Sprintf("types.Types[types.T%s]", strings.ToUpper(t.Name))
	case *ast.SelectorExpr:
		if t.X.(*ast.Ident).Name != "unsafe" || t.Sel.Name != "Pointer" {
			log.Fatalf("unhandled type: %#v", t)
		}
		return "types.Types[types.TUNSAFEPTR]"

	case *ast.ArrayType:
		if t.Len == nil {

func NewMethodType(sig *types.Type, recv *types.Type) *types.Type {
	nrecvs := 0
	if recv != nil {
		nrecvs++
	}

	// TODO(mdempsky): Move this function to types.
	// TODO(mdempsky): Preserve positions, names, and package from sig+recv.

	params := make([]*types.Field, nrecvs+sig.NumParams())
	if recv != nil {
		params[0] = types.NewField(base.Pos, nil, recv)
	}

	x = x << y
	x = x >> y

	z = z + 1
	z = z + 1.0
	z = z + 1.1 // ERROR "truncated to int"
	z = z /* ERROR "mismatched types" */ + y
	z = z /* ERROR "mismatched types" */ - y
	z = z /* ERROR "mismatched types" */ * y
	z = z /* ERROR "mismatched types" */ / y
	z = z /* ERROR "mismatched types" */ % y
	z = z << y
	z = z >> y
}

type myuint uint

func _(x, y uint, z myuint) {
	x = x + 1

// the corresponding generic function or method on the generic type.
func StaticCallee(info *types.Info, call *ast.CallExpr) *types.Func {
	if f, ok := Callee(info, call).(*types.Func); ok && !interfaceMethod(f) {
		return f
	}
	return nil
}

func interfaceMethod(f *types.Func) bool {
	recv := f.Type().(*types.Signature).Recv()
	return recv != nil && types.IsInterface(recv.Type())

	_ = c1a == c2 /* ERROR "mismatched types" */

	// various element types (unnamed types)
	var (
		d1 chan int
		d1r <-chan int
		d1s chan<- int
		d1a chan<- int
		d2 chan float32
	)
	_ = d1 == d1
	_ = d1 == d1r
	_ = d1 == d1s
	_ = d1r == d1s /* ERROR "mismatched types" */
	_ = d1 == d1a
	_ = d1a == d1
	_ = d1 == d2 /* ERROR "mismatched types" */

			c := testConfigArch(t, data.arch)
			boolType := c.config.Types.Bool
			var intType *types.Type
			switch data.intType {
			case "int32":
				intType = c.config.Types.Int32
			case "int8":
				intType = c.config.Types.Int8
			default:
				t.Fatal("invalid integer type:", data.intType)
			}
			fun := c.Fun("entry",
				Bloc("entry",
					Valu("start", OpInitMem, types.TypeMem, 0, nil),