From 1d04c42045df980fdcda87bb7a7a583b74d0fc63 Mon Sep 17 00:00:00 2001 From: Cuong Manh Le Date: Tue, 27 Jun 2023 09:50:57 +0700 Subject: [PATCH] cmd/compile/internal/noder: remove un-used funcs/vars Change-Id: I755406e6c5b6a8cdaeeed8cd12d756e3847c8d4f Reviewed-on: https://go-review.googlesource.com/c/go/+/506475 Reviewed-by: Keith Randall Reviewed-by: Keith Randall Run-TryBot: Cuong Manh Le Reviewed-by: Matthew Dempsky TryBot-Result: Gopher Robot Auto-Submit: Cuong Manh Le --- src/cmd/compile/internal/noder/helpers.go | 103 ---------------------- src/cmd/compile/internal/noder/stmt.go | 30 ------- src/cmd/compile/internal/noder/types.go | 2 - 3 files changed, 135 deletions(-) diff --git a/src/cmd/compile/internal/noder/helpers.go b/src/cmd/compile/internal/noder/helpers.go index ff2d50fcc88..ce63e6fafca 100644 --- a/src/cmd/compile/internal/noder/helpers.go +++ b/src/cmd/compile/internal/noder/helpers.go @@ -77,29 +77,6 @@ func Addr(pos src.XPos, x ir.Node) *ir.AddrExpr { return n } -func Assert(pos src.XPos, x ir.Node, typ *types.Type) ir.Node { - return typed(typ, ir.NewTypeAssertExpr(pos, x, nil)) -} - -func Binary(pos src.XPos, op ir.Op, typ *types.Type, x, y ir.Node) *ir.BinaryExpr { - switch op { - case ir.OADD: - n := ir.NewBinaryExpr(pos, op, x, y) - typed(typ, n) - return n - default: - n := ir.NewBinaryExpr(pos, op, x, y) - typed(x.Type(), n) - return n - } -} - -func Compare(pos src.XPos, typ *types.Type, op ir.Op, x, y ir.Node) *ir.BinaryExpr { - n := ir.NewBinaryExpr(pos, op, x, y) - typed(typ, n) - return n -} - func Deref(pos src.XPos, typ *types.Type, x ir.Node) *ir.StarExpr { n := ir.NewStarExpr(pos, x) typed(typ, n) @@ -122,35 +99,6 @@ func DotField(pos src.XPos, x ir.Node, index int) *ir.SelectorExpr { return dot(pos, field.Type, op, x, field) } -func DotMethod(pos src.XPos, x ir.Node, index int) *ir.SelectorExpr { - method := method(x.Type(), index) - - // Method value. - typ := typecheck.NewMethodType(method.Type, nil) - return dot(pos, typ, ir.OMETHVALUE, x, method) -} - -// MethodExpr returns a OMETHEXPR node with the indicated index into the methods -// of typ. The receiver type is set from recv, which is different from typ if the -// method was accessed via embedded fields. Similarly, the X value of the -// ir.SelectorExpr is recv, the original OTYPE node before passing through the -// embedded fields. -func MethodExpr(pos src.XPos, recv ir.Node, embed *types.Type, index int) *ir.SelectorExpr { - method := method(embed, index) - typ := typecheck.NewMethodType(method.Type, recv.Type()) - // The method expression T.m requires a wrapper when T - // is different from m's declared receiver type. We - // normally generate these wrappers while writing out - // runtime type descriptors, which is always done for - // types declared at package scope. However, we need - // to make sure to generate wrappers for anonymous - // receiver types too. - if recv.Sym() == nil { - typecheck.NeedRuntimeType(recv.Type()) - } - return dot(pos, typ, ir.OMETHEXPR, recv, method) -} - func dot(pos src.XPos, typ *types.Type, op ir.Op, x ir.Node, selection *types.Field) *ir.SelectorExpr { n := ir.NewSelectorExpr(pos, op, x, selection.Sym) n.Selection = selection @@ -158,61 +106,10 @@ func dot(pos src.XPos, typ *types.Type, op ir.Op, x ir.Node, selection *types.Fi return n } -// TODO(mdempsky): Move to package types. -func method(typ *types.Type, index int) *types.Field { - if typ.IsInterface() { - return typ.AllMethods().Index(index) - } - return types.ReceiverBaseType(typ).Methods().Index(index) -} - -func Index(pos src.XPos, typ *types.Type, x, index ir.Node) *ir.IndexExpr { - n := ir.NewIndexExpr(pos, x, index) - typed(typ, n) - return n -} - -func Slice(pos src.XPos, typ *types.Type, x, low, high, max ir.Node) *ir.SliceExpr { - op := ir.OSLICE - if max != nil { - op = ir.OSLICE3 - } - n := ir.NewSliceExpr(pos, op, x, low, high, max) - typed(typ, n) - return n -} - -func Unary(pos src.XPos, typ *types.Type, op ir.Op, x ir.Node) ir.Node { - switch op { - case ir.OADDR: - return Addr(pos, x) - case ir.ODEREF: - return Deref(pos, typ, x) - } - - if op == ir.ORECV { - if typ.IsFuncArgStruct() && typ.NumFields() == 2 { - // Remove the second boolean type (if provided by type2), - // since that works better with the rest of the compiler - // (which will add it back in later). - assert(typ.Field(1).Type.Kind() == types.TBOOL) - typ = typ.Field(0).Type - } - } - return typed(typ, ir.NewUnaryExpr(pos, op, x)) -} - // Statements var one = constant.MakeInt64(1) -func IncDec(pos src.XPos, op ir.Op, x ir.Node) *ir.AssignOpStmt { - assert(x.Type() != nil) - bl := ir.NewBasicLit(pos, one) - bl = typecheck.DefaultLit(bl, x.Type()) - return ir.NewAssignOpStmt(pos, op, x, bl) -} - func idealType(tv syntax.TypeAndValue) types2.Type { // The gc backend expects all expressions to have a concrete type, and // types2 mostly satisfies this expectation already. But there are a few diff --git a/src/cmd/compile/internal/noder/stmt.go b/src/cmd/compile/internal/noder/stmt.go index aa82274f036..04f92d2cf52 100644 --- a/src/cmd/compile/internal/noder/stmt.go +++ b/src/cmd/compile/internal/noder/stmt.go @@ -22,33 +22,3 @@ var callOps = [...]ir.Op{ syntax.Defer: ir.ODEFER, syntax.Go: ir.OGO, } - -// initDefn marks the given names as declared by defn and populates -// its Init field with ODCL nodes. It then reports whether any names -// were so declared, which can be used to initialize defn.Def. -func initDefn(defn ir.InitNode, names []*ir.Name) bool { - if len(names) == 0 { - return false - } - - init := make([]ir.Node, len(names)) - for i, name := range names { - name.Defn = defn - init[i] = ir.NewDecl(name.Pos(), ir.ODCL, name) - } - defn.SetInit(init) - return true -} - -// unpackTwo returns the first two nodes in list. If list has fewer -// than 2 nodes, then the missing nodes are replaced with nils. -func unpackTwo(list []ir.Node) (fst, snd ir.Node) { - switch len(list) { - case 0: - return nil, nil - case 1: - return list[0], nil - default: - return list[0], list[1] - } -} diff --git a/src/cmd/compile/internal/noder/types.go b/src/cmd/compile/internal/noder/types.go index 6caf158c7b2..76c6d15dd83 100644 --- a/src/cmd/compile/internal/noder/types.go +++ b/src/cmd/compile/internal/noder/types.go @@ -9,8 +9,6 @@ import ( "cmd/compile/internal/types2" ) -var universeAny = types2.Universe.Lookup("any").Type() - var basics = [...]**types.Type{ types2.Invalid: new(*types.Type), types2.Bool: &types.Types[types.TBOOL],