Sebastián Ramírez <******@****.***> 1688749933 +0200

  return %0 : tensor<16x4xf32>
}
// Check that the constant is cloned with same value.
// The duplicated constant is the last index of the ConcatV2 op (which
// accepts a variadic arg).
// CHECK-DAG: %[[CST_0:.*]] = "tf.Const"()
// CHECK-SAME: value = dense<1> : tensor<i32>
// CHECK-DAG: %[[CST_1:.*]] = "tf.Const"()
// CHECK-SAME: value = dense<1> : tensor<i32>

// Check that the constants used for tf.ConcatV2 and tf.AddV2 are different.

  return %4 : tensor<1x4x2x2xf32>
}
// CHECK-DAG: %[[WEIGHT_CONST:.+]] = stablehlo.constant {{.*}} : tensor<3x3x2x4xf32>
// CHECK-DAG: %[[BIAS_CONST:.+]] = stablehlo.constant {{.*}} : tensor<1x5x5x4xf32>
// CHECK-DAG: %[[INIT_VALUE_CONST:.+]] = stablehlo.constant dense<0xFF800000> : tensor<f32>

import "go/types"
import "go/constant"

var _ = constant_.Kind
var constant = 23 // Use of new package name.

func f() {
	_ = constant_.MakeBool(true)
}
`,
	},

	var _ = 1e64645      // ERROR "1e\+64645 overflows float64|floating-point constant overflow|exponent too large|overflows float64|overflows"
	var _ = 1e6464       // ERROR "1e\+6464 overflows float64|floating-point constant overflow|overflows float64|overflows"
	var _ = 1e646        // ERROR "1e\+646 overflows float64|floating-point constant overflow|overflows float64|overflows"

/**
 * A Kotlin constant value. This value amy be used as `const val` initializer or annotation argument.
 * Also, may represent evaluated constant value. So, `1 + 2` will be represented as `KaIntConstantValue(3)`
 *
 * For more info about constant values please see [official Kotlin documentation](https://kotlinlang.org/docs/properties.html#compile-time-constants])
 */

      Class<T> enumClass) {
    synchronized (enumConstantCache) {
      Map<String, WeakReference<? extends Enum<?>>> constants = enumConstantCache.get(enumClass);
      if (constants == null) {
        constants = populateCache(enumClass);
      }
      return constants;
    }
  }

  /**
   * Returns a serializable converter that converts between strings and {@code enum} values of type

package constdecl

import "math"
import "unsafe"

var v int

// Const decls must be initialized by constants.
const _ = v /* ERROR "not constant" */
const _ = math /* ERROR "not constant" */ .Sin(0)
const _ = int /* ERROR "not an expression" */

func _() {
	const _ = v /* ERROR "not constant" */
	const _ = math /* ERROR "not constant" */ .Sin(0)
	const _ = int /* ERROR "not an expression" */
}

#include "textflag.h"

// Vector register range containing CRC-32 constants

#define CONST_PERM_LE2BE        V9
#define CONST_R2R1              V10
#define CONST_R4R3              V11
#define CONST_R5                V12
#define CONST_RU_POLY           V13
#define CONST_CRC_POLY          V14


// The CRC-32 constant block contains reduction constants to fold and
// process particular chunks of the input data stream in parallel.

const _ = uintptr(unsafe.Pointer(uintptr(1))) // ERROR "is not (a )?constant|expression is not constant"
const _ = uintptr(myPointer(uintptr(1))) // ERROR "is not (a )?constant|expression is no constant"

const _ = []byte("") // ERROR "is not (a )?constant|invalid constant type"