Skip to content
Snippets Groups Projects
writer.go 48.6 KiB
Newer Older
  • Learn to ignore specific revisions
  • 	if name, ok := sel.X.(*syntax.Name); ok {
    		_, isPkgName := info.Uses[name].(*types2.PkgName)
    		return isPkgName
    	}
    	return false
    }
    
    
    // isMultiValueExpr reports whether expr is a function call expression
    // that yields multiple values.
    func isMultiValueExpr(info *types2.Info, expr syntax.Expr) bool {
    	tv, ok := info.Types[expr]
    	assert(ok)
    	assert(tv.IsValue())
    	if tuple, ok := tv.Type.(*types2.Tuple); ok {
    		assert(tuple.Len() > 1)
    		return true
    	}
    	return false
    }
    
    
    // recvBase returns the base type for the given receiver parameter.
    func recvBase(recv *types2.Var) *types2.Named {
    	typ := recv.Type()
    	if ptr, ok := typ.(*types2.Pointer); ok {
    		typ = ptr.Elem()
    	}
    	return typ.(*types2.Named)
    }
    
    // namesAsExpr returns a list of names as a syntax.Expr.
    func namesAsExpr(names []*syntax.Name) syntax.Expr {
    	if len(names) == 1 {
    		return names[0]
    	}
    
    	exprs := make([]syntax.Expr, len(names))
    	for i, name := range names {
    		exprs[i] = name
    	}
    	return &syntax.ListExpr{ElemList: exprs}
    }
    
    // fieldIndex returns the index of the struct field named by key.
    func fieldIndex(info *types2.Info, str *types2.Struct, key *syntax.Name) int {
    	field := info.Uses[key].(*types2.Var)
    
    	for i := 0; i < str.NumFields(); i++ {
    		if str.Field(i) == field {
    			return i
    		}
    	}
    
    	panic(fmt.Sprintf("%s: %v is not a field of %v", key.Pos(), field, str))
    }
    
    // objTypeParams returns the type parameters on the given object.
    
    func objTypeParams(obj types2.Object) *types2.TypeParamList {
    
    	switch obj := obj.(type) {
    	case *types2.Func:
    
    		sig := obj.Type().(*types2.Signature)
    		if sig.Recv() != nil {
    
    			return sig.RecvTypeParams()
    
    	case *types2.TypeName:
    		if !obj.IsAlias() {
    
    			return obj.Type().(*types2.Named).TypeParams()
    
    		}
    	}
    	return nil
    }
    
    func asPragmaFlag(p syntax.Pragma) ir.PragmaFlag {
    	if p == nil {
    		return 0
    	}
    	return p.(*pragmas).Flag
    }