diff --git a/message/pipeline/extract.go b/message/pipeline/extract.go
index 9be2bac..e006216 100644
--- a/message/pipeline/extract.go
+++ b/message/pipeline/extract.go
@@ -12,16 +12,21 @@
 	"go/format"
 	"go/token"
 	"go/types"
-	"path"
 	"path/filepath"
 	"strings"
 	"unicode"
 	"unicode/utf8"
 
 	fmtparser "golang.org/x/text/internal/format"
+	"golang.org/x/tools/go/callgraph"
+	"golang.org/x/tools/go/callgraph/cha"
 	"golang.org/x/tools/go/loader"
+	"golang.org/x/tools/go/ssa"
+	"golang.org/x/tools/go/ssa/ssautil"
 )
 
+const debug = false
+
 // TODO:
 // - merge information into existing files
 // - handle different file formats (PO, XLIFF)
@@ -39,6 +44,7 @@
 		return nil, wrap(err, "")
 	}
 
+	x.seedEndpoints()
 	x.extractMessages()
 
 	return &State{
@@ -52,23 +58,296 @@
 }
 
 type extracter struct {
-	conf     loader.Config
-	iprog    *loader.Program
+	conf      loader.Config
+	iprog     *loader.Program
+	prog      *ssa.Program
+	callGraph *callgraph.Graph
+
+	// Calls and other expressions to collect.
+	exprs    map[token.Pos]ast.Expr
+	funcs    map[token.Pos]*callData
 	messages []Message
 }
 
 func newExtracter(c *Config) (x *extracter, err error) {
 	x = &extracter{
-		conf: loader.Config{},
+		conf:  loader.Config{},
+		exprs: map[token.Pos]ast.Expr{},
+		funcs: map[token.Pos]*callData{},
 	}
 
 	x.iprog, err = loadPackages(&x.conf, c.Packages)
 	if err != nil {
 		return nil, wrap(err, "")
 	}
+
+	x.prog = ssautil.CreateProgram(x.iprog, 0)
+	x.prog.Build()
+
+	x.callGraph = cha.CallGraph(x.prog)
+
 	return x, nil
 }
 
+func (x *extracter) seedEndpoints() {
+	pkg := x.prog.Package(x.iprog.Package("golang.org/x/text/message").Pkg)
+	typ := types.NewPointer(pkg.Type("Printer").Type())
+
+	x.handleFunc(x.prog.LookupMethod(typ, pkg.Pkg, "Printf"), &callData{
+		formatPos: 1,
+		argPos:    2,
+		isMethod:  true,
+	})
+	x.handleFunc(x.prog.LookupMethod(typ, pkg.Pkg, "Sprintf"), &callData{
+		formatPos: 1,
+		argPos:    2,
+		isMethod:  true,
+	})
+	x.handleFunc(x.prog.LookupMethod(typ, pkg.Pkg, "Fprintf"), &callData{
+		formatPos: 2,
+		argPos:    3,
+		isMethod:  true,
+	})
+}
+
+type callData struct {
+	call    ssa.CallInstruction
+	formats []constant.Value
+
+	callee    *callData
+	isMethod  bool
+	formatPos int
+	argPos    int   // varargs at this position in the call
+	argTypes  []int // arguments extractable from this position
+}
+
+func (c *callData) callFormatPos() int {
+	c = c.callee
+	if c.isMethod {
+		return c.formatPos - 1
+	}
+	return c.formatPos
+}
+
+func (c *callData) callArgsStart() int {
+	c = c.callee
+	if c.isMethod {
+		return c.argPos - 1
+	}
+	return c.argPos
+}
+
+func (c *callData) Pos() token.Pos      { return c.call.Pos() }
+func (c *callData) Pkg() *types.Package { return c.call.Parent().Pkg.Pkg }
+
+func (x *extracter) handleFunc(f *ssa.Function, fd *callData) {
+	for _, e := range x.callGraph.Nodes[f].In {
+		if e.Pos() == 0 {
+			continue
+		}
+
+		call := e.Site
+		caller := x.funcs[call.Pos()]
+		if caller != nil {
+			// TODO: theoretically a format string could be passed to multiple
+			// arguments of a function. Support this eventually.
+			continue
+		}
+		x.debug(call, "CALL", f.String())
+
+		caller = &callData{
+			call:      call,
+			callee:    fd,
+			formatPos: -1,
+			argPos:    -1,
+		}
+		// Offset by one if we are invoking an interface method.
+		offset := 0
+		if call.Common().IsInvoke() {
+			offset = -1
+		}
+		x.funcs[call.Pos()] = caller
+		if fd.argPos >= 0 {
+			x.visitArgs(caller, call.Common().Args[fd.argPos+offset])
+		}
+		x.visitFormats(caller, call.Common().Args[fd.formatPos+offset])
+	}
+}
+
+type posser interface {
+	Pos() token.Pos
+	Parent() *ssa.Function
+}
+
+func (x *extracter) debug(v posser, header string, args ...interface{}) {
+	if debug {
+		pos := ""
+		if p := v.Parent(); p != nil {
+			pos = posString(&x.conf, p.Package().Pkg, v.Pos())
+		}
+		if header != "CALL" && header != "INSERT" {
+			header = "  " + header
+		}
+		fmt.Printf("%-32s%-10s%-15T ", pos+fmt.Sprintf("@%d", v.Pos()), header, v)
+		for _, a := range args {
+			fmt.Printf(" %v", a)
+		}
+		fmt.Println()
+	}
+}
+
+// visitFormats finds the original source of the value. The returned index is
+// position of the argument if originated from a function argument or -1
+// otherwise.
+func (x *extracter) visitFormats(call *callData, v ssa.Value) {
+	if v == nil {
+		return
+	}
+	x.debug(v, "VALUE", v)
+
+	switch v := v.(type) {
+	case *ssa.Phi:
+		for _, e := range v.Edges {
+			x.visitFormats(call, e)
+		}
+
+	case *ssa.Const:
+		// Only record strings with letters.
+		if isMsg(constant.StringVal(v.Value)) {
+			x.debug(call.call, "FORMAT", v.Value.ExactString())
+			call.formats = append(call.formats, v.Value)
+		}
+		// TODO: handle %m-directive.
+
+	case *ssa.Global:
+		// TODO: record value if a string and try to determine a possible
+		// constant value from the ast data.
+
+	case *ssa.FieldAddr, *ssa.Field:
+		// TODO: mark field index v.Field of v.X.Type() for extraction. extract
+		// an example args as to give parameters for the translator.
+
+	case *ssa.Slice:
+		if v.Low == nil && v.High == nil && v.Max == nil {
+			x.visitFormats(call, v.X)
+		}
+
+	case *ssa.Parameter:
+		// TODO: handle the function for the index parameter.
+		f := v.Parent()
+		for i, p := range f.Params {
+			if p == v {
+				if call.formatPos < 0 {
+					call.formatPos = i
+					// TODO: is there a better way to detect this is calling
+					// a method rather than a function?
+					call.isMethod = len(f.Params) > f.Signature.Params().Len()
+					x.handleFunc(v.Parent(), call)
+				} else if debug && i != call.formatPos {
+					// TODO: support this.
+					fmt.Printf("WARNING:%s: format string passed to arg %d and %d\n",
+						posString(&x.conf, call.Pkg(), call.Pos()),
+						call.formatPos, i)
+				}
+			}
+		}
+
+	case *ssa.Alloc:
+		if ref := v.Referrers(); ref == nil {
+			for _, r := range *ref {
+				values := []ssa.Value{}
+				for _, o := range r.Operands(nil) {
+					if o == nil || *o == v {
+						continue
+					}
+					values = append(values, *o)
+				}
+				// TODO: return something different if we care about multiple
+				// values as well.
+				if len(values) == 1 {
+					x.visitFormats(call, values[0])
+				}
+			}
+		}
+
+		// TODO:
+	// case *ssa.Index:
+	// 	// Get all values in the array if applicable
+	// case *ssa.IndexAddr:
+	// 	// Get all values in the slice or *array if applicable.
+	// case *ssa.Lookup:
+	// 	// Get all values in the map if applicable.
+
+	case *ssa.FreeVar:
+		// TODO: find the link between free variables and parameters:
+		//
+		// func freeVar(p *message.Printer, str string) {
+		// 	fn := func(p *message.Printer) {
+		// 		p.Printf(str)
+		// 	}
+		// 	fn(p)
+		// }
+
+	case ssa.Instruction:
+		rands := v.Operands(nil)
+		if len(rands) == 1 && rands[0] != nil {
+			x.visitFormats(call, *rands[0])
+		}
+	case *ssa.Call:
+	}
+}
+
+// Note: a function may have an argument marked as both format and passthrough.
+
+// visitArgs collects information on arguments. For wrapped functions it will
+// just determine the position of the variable args slice.
+func (x *extracter) visitArgs(fd *callData, v ssa.Value) {
+	if v == nil {
+		return
+	}
+	x.debug(v, "ARGV", v)
+	switch v := v.(type) {
+
+	case *ssa.Slice:
+		if v.Low == nil && v.High == nil && v.Max == nil {
+			x.visitArgs(fd, v.X)
+		}
+
+	case *ssa.Parameter:
+		// TODO: handle the function for the index parameter.
+		f := v.Parent()
+		for i, p := range f.Params {
+			if p == v {
+				fd.argPos = i
+			}
+		}
+
+	case *ssa.Alloc:
+		if ref := v.Referrers(); ref == nil {
+			for _, r := range *ref {
+				values := []ssa.Value{}
+				for _, o := range r.Operands(nil) {
+					if o == nil || *o == v {
+						continue
+					}
+					values = append(values, *o)
+				}
+				// TODO: return something different if we care about
+				// multiple values as well.
+				if len(values) == 1 {
+					x.visitArgs(fd, values[0])
+				}
+			}
+		}
+
+	case ssa.Instruction:
+		rands := v.Operands(nil)
+		if len(rands) == 1 && rands[0] != nil {
+			x.visitArgs(fd, *rands[0])
+		}
+	}
+}
+
 func (x *extracter) extractMessages() {
 	// print returns Go syntax for the specified node.
 	print := func(n ast.Node) string {
@@ -95,46 +374,21 @@
 				if !ok {
 					return true
 				}
+				data := x.funcs[call.Lparen]
+				if data == nil || len(data.formats) == 0 {
+					return true
+				}
+				x.debug(data.call, "INSERT", data.formats)
 
-				// Skip calls of functions other than
-				// (*message.Printer).{Sp,Fp,P}rintf.
-				sel, ok := call.Fun.(*ast.SelectorExpr)
-				if !ok {
-					return true
-				}
-				meth := info.Selections[sel]
-				if meth == nil || meth.Kind() != types.MethodVal {
-					return true
-				}
-				// TODO: remove cheap hack and check if the type either
-				// implements some interface or is specifically of type
-				// "golang.org/x/text/message".Printer.
-				m, ok := extractFuncs[path.Base(meth.Recv().String())]
-				if !ok {
-					return true
-				}
-
-				fmtType, ok := m[meth.Obj().Name()]
-				if !ok {
-					return true
-				}
-				// argn is the index of the format string.
-				argn := fmtType.arg
+				argn := data.callFormatPos()
 				if argn >= len(call.Args) {
 					return true
 				}
+				format := call.Args[argn]
 
-				args := call.Args[fmtType.arg:]
-
-				fmtMsg, ok := msgStr(info, args[0])
-				if !ok {
-					// TODO: identify the type of the format argument. If it
-					// is not a string, multiple keys may be defined.
-					return true
-				}
 				comment := ""
 				key := []string{}
-				if ident, ok := args[0].(*ast.Ident); ok {
+				if ident, ok := format.(*ast.Ident); ok {
 					key = append(key, ident.Name)
 					if v, ok := ident.Obj.Decl.(*ast.ValueSpec); ok && v.Comment != nil {
 						// TODO: get comment above ValueSpec as well
@@ -143,36 +397,40 @@
 				}
 
 				arguments := []argument{}
-				args = args[1:]
-				simArgs := make([]interface{}, len(args))
-				for i, arg := range args {
-					expr := print(arg)
-					val := ""
-					if v := info.Types[arg].Value; v != nil {
-						val = v.ExactString()
-						simArgs[i] = val
-						switch arg.(type) {
-						case *ast.BinaryExpr, *ast.UnaryExpr:
-							expr = val
+				simArgs := []interface{}{}
+				if data.callArgsStart() >= 0 {
+					args := call.Args[data.callArgsStart():]
+					simArgs = make([]interface{}, len(args))
+					for i, arg := range args {
+						expr := print(arg)
+						val := ""
+						if v := info.Types[arg].Value; v != nil {
+							val = v.ExactString()
+							simArgs[i] = val
+							switch arg.(type) {
+							case *ast.BinaryExpr, *ast.UnaryExpr:
+								expr = val
+							}
 						}
+						arguments = append(arguments, argument{
+							ArgNum:         i + 1,
+							Type:           info.Types[arg].Type.String(),
+							UnderlyingType: info.Types[arg].Type.Underlying().String(),
+							Expr:           expr,
+							Value:          val,
+							Comment:        getComment(arg),
+							Position:       posString(&x.conf, info.Pkg, arg.Pos()),
+							// TODO report whether it implements
+							// interfaces plural.Interface,
+							// gender.Interface.
+						})
 					}
-					arguments = append(arguments, argument{
-						ArgNum:         i + 1,
-						Type:           info.Types[arg].Type.String(),
-						UnderlyingType: info.Types[arg].Type.Underlying().String(),
-						Expr:           expr,
-						Value:          val,
-						Comment:        getComment(arg),
-						Position:       posString(&x.conf, info.Pkg, arg.Pos()),
-						// TODO report whether it implements
-						// interfaces plural.Interface,
-						// gender.Interface.
-					})
 				}
 
-				formats := []string{fmtMsg}
+				formats := data.formats
 				for _, c := range formats {
-					fmtMsg = c
+					key := append([]string{}, key...)
+					fmtMsg := constant.StringVal(c)
 					msg := ""
 
 					ph := placeholders{index: map[string]string{}}
@@ -235,29 +493,6 @@
 	return filepath.Join(pkg.Path(), file)
 }
 
-// extractFuncs indicates the types and methods for which to extract strings,
-// and which argument to extract.
-// TODO: use the types in conf.Import("golang.org/x/text/message") to extract
-// the correct instances.
-var extractFuncs = map[string]map[string]extractType{
-	// TODO: Printer -> *golang.org/x/text/message.Printer
-	"message.Printer": {
-		"Printf":  extractType{arg: 0, format: true},
-		"Sprintf": extractType{arg: 0, format: true},
-		"Fprintf": extractType{arg: 1, format: true},
-
-		"Lookup": extractType{arg: 0},
-	},
-}
-
-type extractType struct {
-	// format indicates if the next arg is a formatted string or whether to
-	// concatenate all arguments
-	format bool
-	// arg indicates the position of the argument to extract.
-	arg int
-}
-
 func getID(arg *argument) string {
 	s := getLastComponent(arg.Expr)
 	s = strip(s)
@@ -322,17 +557,14 @@
 	return s[1+strings.LastIndexByte(s, '.'):]
 }
 
-func msgStr(info *loader.PackageInfo, e ast.Expr) (s string, ok bool) {
-	v := info.Types[e].Value
-	if v == nil || v.Kind() != constant.String {
-		return "", false
-	}
-	s = constant.StringVal(v)
-	// Only record strings with letters.
+// isMsg returns whether s should be translated.
+func isMsg(s string) bool {
+	// TODO: parse as format string and omit strings that contain letters
+	// coming from format verbs.
 	for _, r := range s {
 		if unicode.In(r, unicode.L) {
-			return s, true
+			return true
 		}
 	}
-	return "", false
+	return false
 }
diff --git a/message/pipeline/testdata/ssa/catalog_gen.go b/message/pipeline/testdata/ssa/catalog_gen.go
new file mode 100644
index 0000000..2e14d5a
--- /dev/null
+++ b/message/pipeline/testdata/ssa/catalog_gen.go
@@ -0,0 +1,37 @@
+// Code generated by running "go generate" in golang.org/x/text. DO NOT EDIT.
+
+package main
+
+import (
+	"golang.org/x/text/language"
+	"golang.org/x/text/message"
+	"golang.org/x/text/message/catalog"
+)
+
+type dictionary struct {
+	index []uint32
+	data  string
+}
+
+func (d *dictionary) Lookup(key string) (data string, ok bool) {
+	p := messageKeyToIndex[key]
+	start, end := d.index[p], d.index[p+1]
+	if start == end {
+		return "", false
+	}
+	return d.data[start:end], true
+}
+
+func init() {
+	dict := map[string]catalog.Dictionary{}
+	fallback := language.MustParse("en-US")
+	cat, err := catalog.NewFromMap(dict, catalog.Fallback(fallback))
+	if err != nil {
+		panic(err)
+	}
+	message.DefaultCatalog = cat
+}
+
+var messageKeyToIndex = map[string]int{}
+
+// Total table size 0 bytes (0KiB); checksum: 811C9DC5
diff --git a/message/pipeline/testdata/ssa/extracted.gotext.json b/message/pipeline/testdata/ssa/extracted.gotext.json
new file mode 100644
index 0000000..cd24934
--- /dev/null
+++ b/message/pipeline/testdata/ssa/extracted.gotext.json
@@ -0,0 +1,229 @@
+{
+    "language": "en-US",
+    "messages": [
+        {
+            "id": "inline {ARG1}",
+            "key": "inline %s",
+            "message": "inline {ARG1}",
+            "translation": "",
+            "placeholders": [
+                {
+                    "id": "ARG1",
+                    "string": "%[1]s",
+                    "type": "string",
+                    "underlyingType": "string",
+                    "argNum": 1,
+                    "expr": "\"ARG1\""
+                }
+            ],
+            "position": "testdata/ssa/ssa.go:16:7"
+        },
+        {
+            "id": "global printer used {ARG1}",
+            "key": "global printer used %s",
+            "message": "global printer used {ARG1}",
+            "translation": "",
+            "placeholders": [
+                {
+                    "id": "ARG1",
+                    "string": "%[1]s",
+                    "type": "string",
+                    "underlyingType": "string",
+                    "argNum": 1,
+                    "expr": "\"ARG1\""
+                }
+            ],
+            "position": "testdata/ssa/ssa.go:17:8"
+        },
+        {
+            "id": "number: {2}, string: {STRING_ARG}, bool: {True}",
+            "key": "number: %d, string: %s, bool: %v",
+            "message": "number: {2}, string: {STRING_ARG}, bool: {True}",
+            "translation": "",
+            "placeholders": [
+                {
+                    "id": "2",
+                    "string": "%[1]d",
+                    "type": "int",
+                    "underlyingType": "int",
+                    "argNum": 1,
+                    "expr": "2"
+                },
+                {
+                    "id": "STRING_ARG",
+                    "string": "%[2]s",
+                    "type": "string",
+                    "underlyingType": "string",
+                    "argNum": 2,
+                    "expr": "\"STRING ARG\""
+                },
+                {
+                    "id": "True",
+                    "string": "%[3]v",
+                    "type": "bool",
+                    "underlyingType": "bool",
+                    "argNum": 3,
+                    "expr": "true"
+                }
+            ],
+            "position": "testdata/ssa/ssa.go:20:9"
+        },
+        {
+            "id": "empty string",
+            "key": "empty string",
+            "message": "empty string",
+            "translation": "",
+            "position": "testdata/ssa/ssa.go:21:9"
+        },
+        {
+            "id": "Lovely weather today!",
+            "key": "Lovely weather today!",
+            "message": "Lovely weather today!",
+            "translation": "",
+            "position": "testdata/ssa/ssa.go:22:8"
+        },
+        {
+            "id": "number one",
+            "key": "number one",
+            "message": "number one",
+            "translation": "",
+            "position": "testdata/ssa/ssa.go:30:8"
+        },
+        {
+            "id": [
+                "v",
+                "number: {C}"
+            ],
+            "key": "number: %d",
+            "message": "number: {C}",
+            "translation": "",
+            "placeholders": [
+                {
+                    "id": "C",
+                    "string": "%[1]d",
+                    "type": "string",
+                    "underlyingType": "string",
+                    "argNum": 1,
+                    "expr": "c"
+                }
+            ],
+            "position": "testdata/ssa/ssa.go:77:10"
+        },
+        {
+            "id": [
+                "format",
+                "constant local {Args}"
+            ],
+            "key": "constant local %s",
+            "message": "constant local {Args}",
+            "translation": "",
+            "placeholders": [
+                {
+                    "id": "Args",
+                    "string": "%[1]s",
+                    "type": "[]interface{}",
+                    "underlyingType": "[]interface{}",
+                    "argNum": 1,
+                    "expr": "args"
+                }
+            ],
+            "position": "testdata/ssa/ssa.go:86:11"
+        },
+        {
+            "id": [
+                "a",
+                "foo {Arg1} {B}"
+            ],
+            "key": "foo %s %s",
+            "message": "foo {Arg1} {B}",
+            "translation": "",
+            "placeholders": [
+                {
+                    "id": "Arg1",
+                    "string": "%[1]s",
+                    "type": "string",
+                    "underlyingType": "string",
+                    "argNum": 1,
+                    "expr": "arg1"
+                },
+                {
+                    "id": "B",
+                    "string": "%[2]s",
+                    "type": "string",
+                    "underlyingType": "string",
+                    "argNum": 2,
+                    "expr": "b"
+                }
+            ],
+            "position": "testdata/ssa/ssa.go:137:7"
+        },
+        {
+            "id": [
+                "a",
+                "bar {Arg1} {B}"
+            ],
+            "key": "bar %s %s",
+            "message": "bar {Arg1} {B}",
+            "translation": "",
+            "placeholders": [
+                {
+                    "id": "Arg1",
+                    "string": "%[1]s",
+                    "type": "string",
+                    "underlyingType": "string",
+                    "argNum": 1,
+                    "expr": "arg1"
+                },
+                {
+                    "id": "B",
+                    "string": "%[2]s",
+                    "type": "string",
+                    "underlyingType": "string",
+                    "argNum": 2,
+                    "expr": "b"
+                }
+            ],
+            "position": "testdata/ssa/ssa.go:137:7"
+        },
+        {
+            "id": [
+                "a",
+                "foo"
+            ],
+            "key": "foo",
+            "message": "foo",
+            "translation": "",
+            "position": "testdata/ssa/ssa.go:151:8"
+        },
+        {
+            "id": [
+                "a",
+                "bar"
+            ],
+            "key": "bar",
+            "message": "bar",
+            "translation": "",
+            "position": "testdata/ssa/ssa.go:151:8"
+        },
+        {
+            "id": [
+                "a",
+                "baz"
+            ],
+            "key": "baz",
+            "message": "baz",
+            "translation": "",
+            "position": "testdata/ssa/ssa.go:151:8"
+        },
+        {
+            "id": [
+                "str",
+                "const str"
+            ],
+            "key": "const str",
+            "message": "const str",
+            "translation": "",
+            "position": "testdata/ssa/ssa.go:165:11"
+        }
+    ]
+}
\ No newline at end of file
diff --git a/message/pipeline/testdata/ssa/ssa.go b/message/pipeline/testdata/ssa/ssa.go
new file mode 100644
index 0000000..aae2e8d
--- /dev/null
+++ b/message/pipeline/testdata/ssa/ssa.go
@@ -0,0 +1,175 @@
+package main
+
+import (
+	"golang.org/x/text/language"
+	"golang.org/x/text/message"
+)
+
+// In this test, lowercap strings are ones that need to be picked up for
+// translation, whereas uppercap strings should not be picked up.
+
+func main() {
+	p := message.NewPrinter(language.English)
+
+	// TODO: probably should use type instead of string content for argument
+	// substitution.
+	wrapf(p, "inline %s", "ARG1")
+	gwrapf("global printer used %s", "ARG1")
+
+	w := wrapped{p}
+	w.wrapf("number: %d, string: %s, bool: %v", 2, "STRING ARG", true)
+	w.wrapf("empty string")
+	w.wrap("Lovely weather today!")
+
+	more(&w)
+}
+
+var printer = message.NewPrinter(language.English)
+
+func more(w wrapper) {
+	w.wrap("number one")
+	w.wrapf("speed of light: %s", "C")
+}
+
+func gwrapf(format string, args ...interface{}) {
+	v := format
+	a := args
+	printer.Printf(v, a...)
+}
+
+func wrapf(p *message.Printer, format string, args ...interface{}) {
+	v := format
+	a := args
+	p.Printf(v, a...)
+}
+
+func wrap(p *message.Printer, format string) {
+	v := format
+	b := "0"
+	a := []interface{}{3, b}
+	s := a[:]
+	p.Printf(v, s...)
+}
+
+type wrapper interface {
+	wrapf(format string, args ...interface{})
+	wrap(msg string)
+}
+
+type wrapped struct {
+	p *message.Printer
+}
+
+// TODO: calls over interfaces do not get picked up. It looks like this is
+// because w is not a pointer receiver, while the other method is. Mixing of
+// receiver types does not seem to be allowed by callgraph/cha.
+func (w wrapped) wrapf(format string, args ...interface{}) {
+	w.p.Printf(format, args...)
+}
+
+func (w *wrapped) wrap(msg string) {
+	w.p.Printf(msg)
+}
+
+func fint(p *message.Printer, x int) {
+	v := "number: %d"
+	const c = "DAFDA"
+	p.Printf(v, c)
+}
+
+const format = "constant local" + " %s"
+
+// NOTE: pass is not called. Ensure it is picked up anyway.
+func pass(p *message.Printer, args ...interface{}) {
+	// TODO: find an example caller to find substituted types and argument
+	// examples.
+	p.Sprintf(format, args...)
+}
+
+func lookup(p *message.Printer, x int) {
+	// TODO: pick up all elements from slice foo.
+	p.Printf(foo[x])
+}
+
+var foo = []string{
+	"aaaa",
+	"bbbb",
+}
+
+func field(p *message.Printer, x int) {
+	// TODO: pick up strings in field BAR from all composite literals of
+	// typeof(strct.Foo.Bar).
+	p.Printf(strct.Foo.Bar, x)
+}
+
+type fooStruct struct {
+	Foo barStruct
+}
+
+type barStruct struct {
+	other int
+	Bar   string
+}
+
+var strct = fooStruct{
+	Foo: barStruct{0, "foo %d"},
+}
+
+func call(p *message.Printer, x int) {
+	// TODO: pick up constant return values.
+	p.Printf(fn())
+}
+
+func fn() string {
+	return "const str"
+}
+
+// Both strings get picked up.
+func ifConst(p *message.Printer, cond bool, arg1 string) {
+	a := "foo %s %s"
+	if cond {
+		a = "bar %s %s"
+	}
+	b := "FOO"
+	if cond {
+		b = "BAR"
+	}
+	wrapf(p, a, arg1, b)
+}
+
+// Pick up all non-empty strings in this function.
+func ifConst2(x int) {
+	a := ""
+	switch x {
+	case 0:
+		a = "foo"
+	case 1:
+		a = "bar"
+	case 2:
+		a = "baz"
+	}
+	gwrapf(a)
+}
+
+// TODO: pick up strings passed to the second argument in calls to freeVar.
+func freeVar(p *message.Printer, str string) {
+	fn := func(p *message.Printer) {
+		p.Printf(str)
+	}
+	fn(p)
+}
+
+func freeConst(p *message.Printer) {
+	const str = "const str"
+	fn := func(p *message.Printer) {
+		p.Printf(str)
+	}
+	fn(p)
+}
+
+func global(p *message.Printer) {
+	// TODO: pick up evaluations of globals to string.
+	p.Printf(globalStr)
+}
+
+var globalStr = "global string"