m int   = 1.0 << s       // legal: 1.0 has type int
	w int64 = 1.0 << 33      // legal: 1.0<<33 is a constant shift expression
)

// non-constant shift expressions
var (
	a1 int = 2.0 << s    // typeof(2.0) is int in this context => legal shift
	d1     = f(2.0 << s) // typeof(2.0) is int in this context => legal shift
)

// constant shift expressions
const c uint = 5

var (
	a2 int     = 2.0 << c    // a2 == 64 (type int)

	if err != nil {
		log.Fatal(err)
	}
	err = os.WriteFile(*filename, data, 0644)
	if err != nil {
		log.Fatal(err)
	}
}

type Data struct {
	a, b, c, d string
	Shift1     []int
	Shift2     []int
	Shift3     []int
	Shift4     []int
	Table1     []uint32
	Table2     []uint32
	Table3     []uint32
	Table4     []uint32
}

var funcs = template.FuncMap{
	"dup":     dup,
	"relabel": relabel,

	_ = 1<<s == 1.  // ERROR "invalid|shift of type float64"
	_ = 1.<<s == 1  // ERROR "invalid|shift of type float64"
	_ = 1.<<s == 1. // ERROR "invalid|non-integer|shift of type float64"

	_ = 1<<s+1 == 1
	_ = 1<<s+1 == 1.   // ERROR "invalid|shift of type float64"
	_ = 1<<s+1. == 1   // ERROR "invalid|shift of type float64"
	_ = 1<<s+1. == 1.  // ERROR "invalid|shift of type float64"
	_ = 1.<<s+1 == 1   // ERROR "invalid|shift of type float64"

			}
		}
	})
	return nil, nil
}

// checkLongShift checks if shift or shift-assign operations shift by more than
// the length of the underlying variable.
func checkLongShift(pass *analysis.Pass, node ast.Node, x, y ast.Expr) {
	if pass.TypesInfo.Types[x].Value != nil {
		// Ignore shifts of constants.
		// These are frequently used for bit-twiddling tricks

// Copyright 2022 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// The following shift tests are disabled in the shared
// testdata/check/shifts.go file because they don't work
// correctly with types2 at the moment. See go.dev/issue/52080.
// Make sure we keep testing them with go/types.
//
// TODO(gri) Once go.dev/issue/52080 is fixed, this file can be

	f(x<<(1<<x), 4)
	f(x<<(1.<<x), 4)
	f(x<<((1+0i)<<x), 4)
	f(x<<(0i<<x), 1)

	// corner cases
	const M = math.MaxUint
	f(x<<(M+0), 0)     // shift by untyped int representable as uint
	f(x<<(M+0.), 0)    // shift by untyped float representable as uint
	f(x<<(M+0.+0i), 0) // shift by untyped complex representable as uint

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// This file contains tests for the suspicious shift checker.

package shift

func ShiftTest() {
	var i8 int8
	_ = i8 << 7
	_ = (i8 + 1) << 8 // ERROR ".i8 . 1. .8 bits. too small for shift of 8"

// run

// Copyright 2009 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Test shift.

package main

var	ians	[18]int;
var	uans	[18]uint;
var	pass	string;

func
testi(i int, t1,t2,t3 int) {
	n := ((t1*3) + t2)*2 + t3;
	if i != ians[n] {
		print("itest ", t1,t2,t3,pass,
			" is ", i, " sb ", ians[n], "\n");
	}
}

	return x<<7 ^ x2>>25 // arm64:"EXTRW\t[$]25,"
}

// check 32-bit shift masking
func mask32(x uint32) uint32 {
	return (x << 29) >> 29 // arm64:"AND\t[$]7, R[0-9]+",-"LSR",-"LSL"
}

// check 16-bit shift masking
func mask16(x uint16) uint16 {
	return (x << 14) >> 14 // arm64:"AND\t[$]3, R[0-9]+",-"LSR",-"LSL"
}

// check 8-bit shift masking
func mask8(x uint8) uint8 {

Klaus Post <******@****.***> 1457448890 +0100