diff --git a/cue/ast/astutil/sanitize.go b/cue/ast/astutil/sanitize.go
index 98f9fc820..95abdda98 100644
--- a/cue/ast/astutil/sanitize.go
+++ b/cue/ast/astutil/sanitize.go
@@ -347,7 +347,7 @@ func (z *sanitizer) uniqueName(base string, hidden bool) string {
 
 	const mask = 0xff_ffff_ffff_ffff // max bits; stay clear of int64 overflow
 	const shift = 4                  // rate of growth
-	for n := int64(0x10); ; n = int64(mask&((n<<shift)-1)) + 1 {
+	for n := int64(0x10); ; n = mask&((n<<shift)-1) + 1 {
 		num := z.rand.Intn(int(n))
 		name := fmt.Sprintf("%s_%01X", base, num)
 		if !z.names[name] {
diff --git a/cue/parser/error_test.go b/cue/parser/error_test.go
index 7045dadb7..74318084c 100644
--- a/cue/parser/error_test.go
+++ b/cue/parser/error_test.go
@@ -83,7 +83,7 @@ func expectedErrors(t *testing.T, file *token.File, src []byte) map[token.Pos]st
 				if s[1] == "HERE" {
 					pos = here
 				}
-				errors[pos] = string(s[2])
+				errors[pos] = s[2]
 			}
 		default:
 			prev = pos
diff --git a/cue/token/position.go b/cue/token/position.go
index 8d194d051..d22685e0c 100644
--- a/cue/token/position.go
+++ b/cue/token/position.go
@@ -414,7 +414,7 @@ func (f *File) Pos(offset int, rel RelPos) Pos {
 // f.Offset(f.Pos(offset)) == offset.
 func (f *File) Offset(p Pos) int {
 	x := p.index()
-	if x < 1 || x > 1+index(f.size) {
+	if x < 1 || x > 1+f.size {
 		panic("illegal Pos value")
 	}
 	return int(x - 1)
@@ -436,7 +436,7 @@ func searchLineInfos(a []lineInfo, x int) int {
 func (f *File) unpack(offset index, adjusted bool) (filename string, line, column int) {
 	filename = f.name
 	if i := searchInts(f.lines, offset); i >= 0 {
-		line, column = int(i+1), int(offset-f.lines[i]+1)
+		line, column = i+1, int(offset-f.lines[i]+1)
 	}
 	if adjusted && len(f.infos) > 0 {
 		// almost no files have extra line infos
diff --git a/cue/types.go b/cue/types.go
index 185abf8fc..bcd6e023d 100644
--- a/cue/types.go
+++ b/cue/types.go
@@ -1095,7 +1095,7 @@ func (v Value) checkKind(ctx *adt.OpContext, want adt.Kind) *adt.Bottom {
 
 func makeInt(v Value, x int64) Value {
 	n := &adt.Num{K: adt.IntKind}
-	n.X.SetInt64(int64(x))
+	n.X.SetInt64(x)
 	return remakeFinal(v, n)
 }
 
diff --git a/cue/types_test.go b/cue/types_test.go
index 69b2f9eba..c682d42fe 100644
--- a/cue/types_test.go
+++ b/cue/types_test.go
@@ -421,7 +421,7 @@ func TestInt(t *testing.T) {
 
 			vu, err := n.Uint64()
 			checkErr(t, err, tc.errU, "Uint64")
-			if vu != uint64(tc.uint) {
+			if vu != tc.uint {
 				t.Errorf("Uint64: got %v; want %v", vu, tc.uint)
 			}
 		})
diff --git a/encoding/openapi/build.go b/encoding/openapi/build.go
index 8074dbc8a..89ee9cbaf 100644
--- a/encoding/openapi/build.go
+++ b/encoding/openapi/build.go
@@ -257,7 +257,7 @@ func (b *builder) fillSchema(v cue.Value) *ast.StructLit {
 	}
 
 	schema := b.finish()
-	s := (*ast.StructLit)(schema)
+	s := schema
 
 	simplify(b, s)
 
@@ -529,7 +529,7 @@ func (b *builder) disjunction(a []cue.Value, f typeFunc) {
 		c := newOASBuilder(b)
 		c.value(v, f)
 		t := c.finish()
-		schemas[i] = (*ast.StructLit)(t)
+		schemas[i] = t
 		if len(t.Elts) == 0 {
 			if c.typ == "" {
 				return
@@ -1207,7 +1207,7 @@ func (b *builder) add(t *ast.StructLit) {
 func (b *builder) addConjunct(f func(*builder)) {
 	c := newOASBuilder(b)
 	f(c)
-	b.add((*ast.StructLit)(c.finish()))
+	b.add(c.finish())
 }
 
 func (b *builder) addRef(v cue.Value, inst cue.Value, ref cue.Path) {
diff --git a/internal/core/compile/label.go b/internal/core/compile/label.go
index 24bed7d4b..2d0daf573 100644
--- a/internal/core/compile/label.go
+++ b/internal/core/compile/label.go
@@ -44,7 +44,7 @@ func (c *compiler) label(n ast.Node) adt.Feature {
 				return adt.InvalidLabel
 			}
 
-			i := int64(index.StringToIndex(norm.NFC.String(s)))
+			i := index.StringToIndex(norm.NFC.String(s))
 			f, err := adt.MakeLabel(n, i, adt.StringLabel)
 			if err != nil {
 				c.errf(n, msg, err)
diff --git a/internal/core/convert/go.go b/internal/core/convert/go.go
index 30282fb62..72e8c36f9 100644
--- a/internal/core/convert/go.go
+++ b/internal/core/convert/go.go
@@ -344,7 +344,7 @@ func (c *goConverter) convertRec(nilIsTop bool, x interface{}) (result adt.Value
 	case int32:
 		return c.toInt(int64(v))
 	case int64:
-		return c.toInt(int64(v))
+		return c.toInt(v)
 	case uint:
 		return c.toUint(uint64(v))
 	case uint8:
@@ -354,7 +354,7 @@ func (c *goConverter) convertRec(nilIsTop bool, x interface{}) (result adt.Value
 	case uint32:
 		return c.toUint(uint64(v))
 	case uint64:
-		return c.toUint(uint64(v))
+		return c.toUint(v)
 	case uintptr:
 		return c.toUint(uint64(v))
 	case float64:
diff --git a/internal/core/export/export.go b/internal/core/export/export.go
index 331b39f38..2d5eda2fd 100644
--- a/internal/core/export/export.go
+++ b/internal/core/export/export.go
@@ -686,7 +686,7 @@ func findUnique(set featureSet, base string) (f adt.Feature, name string) {
 	const mask = 0xff_ffff_ffff_ffff // max bits; stay clear of int64 overflow
 	const shift = 4                  // rate of growth
 	digits := 1
-	for n := int64(0x10); ; n = int64(mask&((n<<shift)-1)) + 1 {
+	for n := int64(0x10); ; n = mask&((n<<shift)-1) + 1 {
 		num := set.intn(int(n)-1) + 1
 		name := fmt.Sprintf("%[1]s_%0[2]*[3]X", base, digits, num)
 		if f, ok := set.makeFeature(name); ok {
diff --git a/internal/core/export/label.go b/internal/core/export/label.go
index 204912b5b..5de459bdc 100644
--- a/internal/core/export/label.go
+++ b/internal/core/export/label.go
@@ -31,7 +31,7 @@ func (e *exporter) stringLabel(f adt.Feature) ast.Label {
 	x := f.Index()
 	switch f.Typ() {
 	case adt.IntLabel:
-		return ast.NewLit(token.INT, strconv.Itoa(int(x)))
+		return ast.NewLit(token.INT, strconv.Itoa(x))
 
 	case adt.DefinitionLabel, adt.HiddenLabel, adt.HiddenDefinitionLabel:
 		s := e.identString(f)
diff --git a/internal/core/export/value_test.go b/internal/core/export/value_test.go
index d7fe1bec6..34c4506f4 100644
--- a/internal/core/export/value_test.go
+++ b/internal/core/export/value_test.go
@@ -110,8 +110,8 @@ func TestValueX(t *testing.T) {
 	a := cuetxtar.Load(archive, t.TempDir())
 
 	r := runtime.New()
-	(*runtime.Runtime)(r).SetVersion(internal.DevVersion)
-	(*runtime.Runtime)(r).SetDebugOptions(&cuedebug.Config{Sharing: true})
+	r.SetVersion(internal.DevVersion)
+	r.SetDebugOptions(&cuedebug.Config{Sharing: true})
 
 	v, errs := compile.Files(nil, r, "", a[0].Files...)
 	if errs != nil {
diff --git a/internal/mod/modpkgload/pkgload_test.go b/internal/mod/modpkgload/pkgload_test.go
index 21d1cb1ef..71e4dfe72 100644
--- a/internal/mod/modpkgload/pkgload_test.go
+++ b/internal/mod/modpkgload/pkgload_test.go
@@ -88,7 +88,7 @@ func TestLoadPackages(t *testing.T) {
 						}
 					}
 				}
-				if diff := cmp.Diff(string(want), out.String()); diff != "" {
+				if diff := cmp.Diff(want, out.String()); diff != "" {
 					t.Logf("actual result:\n%s", out.String())
 					t.Fatalf("unexpected results (-want +got):\n%s", diff)
 				}
diff --git a/internal/pkg/context.go b/internal/pkg/context.go
index ff0315a92..9db9d26f4 100644
--- a/internal/pkg/context.go
+++ b/internal/pkg/context.go
@@ -109,7 +109,7 @@ func (c *CallCtxt) Int8(i int) int8   { return int8(c.intValue(i, 8, "int8")) }
 func (c *CallCtxt) Int16(i int) int16 { return int16(c.intValue(i, 16, "int16")) }
 func (c *CallCtxt) Int32(i int) int32 { return int32(c.intValue(i, 32, "int32")) }
 func (c *CallCtxt) Rune(i int) rune   { return rune(c.intValue(i, 32, "rune")) }
-func (c *CallCtxt) Int64(i int) int64 { return int64(c.intValue(i, 64, "int64")) }
+func (c *CallCtxt) Int64(i int) int64 { return c.intValue(i, 64, "int64") }
 
 func (c *CallCtxt) intValue(i, bits int, typ string) int64 {
 	arg := c.args[i]
@@ -132,7 +132,7 @@ func (c *CallCtxt) Uint8(i int) uint8   { return uint8(c.uintValue(i, 8, "uint8"
 func (c *CallCtxt) Byte(i int) uint8    { return byte(c.uintValue(i, 8, "byte")) }
 func (c *CallCtxt) Uint16(i int) uint16 { return uint16(c.uintValue(i, 16, "uint16")) }
 func (c *CallCtxt) Uint32(i int) uint32 { return uint32(c.uintValue(i, 32, "uint32")) }
-func (c *CallCtxt) Uint64(i int) uint64 { return uint64(c.uintValue(i, 64, "uint64")) }
+func (c *CallCtxt) Uint64(i int) uint64 { return c.uintValue(i, 64, "uint64") }
 
 func (c *CallCtxt) uintValue(i, bits int, typ string) uint64 {
 	x := value.Make(c.ctx, c.args[i])
diff --git a/pkg/uuid/uuid.go b/pkg/uuid/uuid.go
index d164a5259..a1c2c02ba 100644
--- a/pkg/uuid/uuid.go
+++ b/pkg/uuid/uuid.go
@@ -35,19 +35,19 @@ func Valid(s string) error {
 // encoding: xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.
 func Parse(s string) (string, error) {
 	x, err := uuid.Parse(s)
-	return string(x.String()), err
+	return x.String(), err
 }
 
 // TODO(mvdan): what is ToString meant to do? it appears like a no-op?
 
 // String represents a 128-bit UUID value as a string.
 func ToString(x string) string {
-	return string(x)
+	return x
 }
 
 // URN reports the canonical URN of a UUID.
 func URN(x string) (string, error) {
-	u, err := uuid.Parse(string(x))
+	u, err := uuid.Parse(x)
 	if err != nil {
 		return "", err
 	}
@@ -66,7 +66,7 @@ func FromInt(i *big.Int) (string, error) {
 		b = buf[:]
 	}
 	u, err := uuid.FromBytes(b)
-	return string(u.String()), err
+	return u.String(), err
 }
 
 // ToInt represents a UUID string as a 128-bit value.
@@ -78,7 +78,7 @@ func ToInt(x string) *big.Int {
 
 // Variant reports the UUID variant.
 func Variant(x string) (int, error) {
-	u, err := uuid.Parse(string(x))
+	u, err := uuid.Parse(x)
 	if err != nil {
 		return 0, err
 	}
@@ -87,7 +87,7 @@ func Variant(x string) (int, error) {
 
 // Version reports the UUID version.
 func Version(x string) (int, error) {
-	u, err := uuid.Parse(string(x))
+	u, err := uuid.Parse(x)
 	if err != nil {
 		return 0, err
 	}
@@ -96,19 +96,19 @@ func Version(x string) (int, error) {
 
 // SHA1 generates a version 5 UUID based on the supplied name space and data.
 func SHA1(space string, data []byte) (string, error) {
-	u, err := uuid.Parse(string(space))
+	u, err := uuid.Parse(space)
 	if err != nil {
 		return "", err
 	}
-	return string(uuid.NewSHA1(u, data).String()), nil
+	return uuid.NewSHA1(u, data).String(), nil
 }
 
 // MD5 generates a version 3 UUID based on the supplied name space and data.
 // Use SHA1 instead if you can.
 func MD5(space string, data []byte) (string, error) {
-	u, err := uuid.Parse(string(space))
+	u, err := uuid.Parse(space)
 	if err != nil {
 		return "", err
 	}
-	return string(uuid.NewMD5(u, data).String()), nil
+	return uuid.NewMD5(u, data).String(), nil
 }