func buildPkgSym(b *builder, m *tast.MemberExpr, pkg *types.Pkg) *ref { sym := m.Symbol if pkg.Lang == "asm8" { switch sym.Type { case asm8.SymVar: if m.Type() != types.Uint { panic("bug") } ptr := b.newTemp(types.Uint) s := ir.NewHeapSym(sym.Pkg(), sym.Name(), 0, false, false) b.b.Arith(ptr.IR(), nil, "&", s) return ptr case asm8.SymFunc: if !types.SameType(m.Type(), types.VoidFunc) { panic("bug") } return newRef( types.VoidFunc, ir.NewFuncSym(sym.Pkg(), sym.Name(), ir.VoidFuncSig), ) } panic("bug") } switch sym.Type { case tast.SymConst: return sym.Obj.(*objConst).ref case tast.SymVar: return sym.Obj.(*objVar).ref case tast.SymFunc: return sym.Obj.(*objFunc).ref } panic("bug") }
func findFunc(b *builder, name string, t types.T) *objFunc { s := b.scope.Query(name) if s == nil { return nil } f, isFunc := s.Obj.(*objFunc) if !isFunc { return nil } if !types.SameType(f.ref.Type(), t) { return nil } return f }
func listTests(tops *sym8.Table) []*objFunc { var list []*objFunc syms := tops.List() for _, s := range syms { if s.Type != tast.SymFunc { continue } f := s.Obj.(*objFunc) if f.isMethod { panic("bug") // a top level function should never be a method } if !types.SameType(f.ref.Type(), types.VoidFunc) { continue } name := s.Name() if isTestName(name) { list = append(list, f) } } return list }
func buildCallMake(b *builder, expr *ast.CallExpr, f tast.Expr) tast.Expr { args := buildExprList(b, expr.Args) if args == nil { return nil } n := args.R().Len() if n == 0 { b.Errorf(expr.Lparen.Pos, "make() takes at least one argument") return nil } argsList, ok := tast.MakeExprList(args) if !ok { b.Errorf(expr.Lparen.Pos, "make() only takes a literal list") return nil } arg0 := argsList.Exprs[0] t, ok := arg0.R().T.(*types.Type) if !ok { b.Errorf(expr.Lparen.Pos, "make() takes a type as the 1st argument") return nil } switch st := t.T.(type) { case *types.Slice: if n != 3 { b.Errorf(expr.Lparen.Pos, "make() slice takes 3 arguments") return nil } size := argsList.Exprs[1] pos := ast.ExprPos(expr.Args.Exprs[1]) size = checkArrayIndex(b, size, pos) if size == nil { return nil } start := argsList.Exprs[2] startType := start.R().T startPos := ast.ExprPos(expr.Args.Exprs[2]) if v, ok := types.NumConst(startType); ok { start = constCastUint(b, startPos, v, start) if start == nil { return nil } } else if !types.IsBasic(startType, types.Uint) { pt := types.PointerOf(startType) if pt == nil || !types.SameType(pt, st.T) { b.Errorf(startPos, "make() takes an uint or a typed pointer as the 3rd arg", ) return nil } } callArgs := tast.NewExprList() callArgs.Append(arg0) callArgs.Append(size) callArgs.Append(start) r := tast.NewRef(st) return &tast.CallExpr{f, callArgs, r} } b.Errorf(expr.Lparen.Pos, "cannot make() type %s", t.T) return nil }