diff --git a/mockgen/model/model.go b/mockgen/model/model.go
index 853dbf2d..ec8004d0 100644
--- a/mockgen/model/model.go
+++ b/mockgen/model/model.go
@@ -19,7 +19,6 @@ import (
 	"encoding/gob"
 	"fmt"
 	"io"
-	"reflect"
 	"strings"
 )
 
@@ -335,187 +334,6 @@ func (tp *TypeParametersType) addImports(im map[string]bool) {
 	}
 }
 
-// The following code is intended to be called by the program generated by ../reflect.go.
-
-// InterfaceFromInterfaceType returns a pointer to an interface for the
-// given reflection interface type.
-func InterfaceFromInterfaceType(it reflect.Type) (*Interface, error) {
-	if it.Kind() != reflect.Interface {
-		return nil, fmt.Errorf("%v is not an interface", it)
-	}
-	intf := &Interface{}
-
-	for i := 0; i < it.NumMethod(); i++ {
-		mt := it.Method(i)
-		// TODO: need to skip unexported methods? or just raise an error?
-		m := &Method{
-			Name: mt.Name,
-		}
-
-		var err error
-		m.In, m.Variadic, m.Out, err = funcArgsFromType(mt.Type)
-		if err != nil {
-			return nil, err
-		}
-
-		intf.AddMethod(m)
-	}
-
-	return intf, nil
-}
-
-// t's Kind must be a reflect.Func.
-func funcArgsFromType(t reflect.Type) (in []*Parameter, variadic *Parameter, out []*Parameter, err error) {
-	nin := t.NumIn()
-	if t.IsVariadic() {
-		nin--
-	}
-	var p *Parameter
-	for i := 0; i < nin; i++ {
-		p, err = parameterFromType(t.In(i))
-		if err != nil {
-			return
-		}
-		in = append(in, p)
-	}
-	if t.IsVariadic() {
-		p, err = parameterFromType(t.In(nin).Elem())
-		if err != nil {
-			return
-		}
-		variadic = p
-	}
-	for i := 0; i < t.NumOut(); i++ {
-		p, err = parameterFromType(t.Out(i))
-		if err != nil {
-			return
-		}
-		out = append(out, p)
-	}
-	return
-}
-
-func parameterFromType(t reflect.Type) (*Parameter, error) {
-	tt, err := typeFromType(t)
-	if err != nil {
-		return nil, err
-	}
-	return &Parameter{Type: tt}, nil
-}
-
-var errorType = reflect.TypeOf((*error)(nil)).Elem()
-
-var byteType = reflect.TypeOf(byte(0))
-
-func typeFromType(t reflect.Type) (Type, error) {
-	// Hack workaround for https://golang.org/issue/3853.
-	// This explicit check should not be necessary.
-	if t == byteType {
-		return PredeclaredType("byte"), nil
-	}
-
-	if imp := t.PkgPath(); imp != "" {
-		return &NamedType{
-			Package: impPath(imp),
-			Type:    t.Name(),
-		}, nil
-	}
-
-	// only unnamed or predeclared types after here
-
-	// Lots of types have element types. Let's do the parsing and error checking for all of them.
-	var elemType Type
-	switch t.Kind() {
-	case reflect.Array, reflect.Chan, reflect.Map, reflect.Ptr, reflect.Slice:
-		var err error
-		elemType, err = typeFromType(t.Elem())
-		if err != nil {
-			return nil, err
-		}
-	}
-
-	switch t.Kind() {
-	case reflect.Array:
-		return &ArrayType{
-			Len:  t.Len(),
-			Type: elemType,
-		}, nil
-	case reflect.Bool, reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64,
-		reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr,
-		reflect.Float32, reflect.Float64, reflect.Complex64, reflect.Complex128, reflect.String:
-		return PredeclaredType(t.Kind().String()), nil
-	case reflect.Chan:
-		var dir ChanDir
-		switch t.ChanDir() {
-		case reflect.RecvDir:
-			dir = RecvDir
-		case reflect.SendDir:
-			dir = SendDir
-		}
-		return &ChanType{
-			Dir:  dir,
-			Type: elemType,
-		}, nil
-	case reflect.Func:
-		in, variadic, out, err := funcArgsFromType(t)
-		if err != nil {
-			return nil, err
-		}
-		return &FuncType{
-			In:       in,
-			Out:      out,
-			Variadic: variadic,
-		}, nil
-	case reflect.Interface:
-		// Two special interfaces.
-		if t.NumMethod() == 0 {
-			return PredeclaredType("any"), nil
-		}
-		if t == errorType {
-			return PredeclaredType("error"), nil
-		}
-	case reflect.Map:
-		kt, err := typeFromType(t.Key())
-		if err != nil {
-			return nil, err
-		}
-		return &MapType{
-			Key:   kt,
-			Value: elemType,
-		}, nil
-	case reflect.Ptr:
-		return &PointerType{
-			Type: elemType,
-		}, nil
-	case reflect.Slice:
-		return &ArrayType{
-			Len:  -1,
-			Type: elemType,
-		}, nil
-	case reflect.Struct:
-		if t.NumField() == 0 {
-			return PredeclaredType("struct{}"), nil
-		}
-	}
-
-	// TODO: Struct, UnsafePointer
-	return nil, fmt.Errorf("can't yet turn %v (%v) into a model.Type", t, t.Kind())
-}
-
-// impPath sanitizes the package path returned by `PkgPath` method of a reflect Type so that
-// it is importable. PkgPath might return a path that includes "vendor". These paths do not
-// compile, so we need to remove everything up to and including "/vendor/".
-// See https://github.com/golang/go/issues/12019.
-func impPath(imp string) string {
-	if strings.HasPrefix(imp, "vendor/") {
-		imp = "/" + imp
-	}
-	if i := strings.LastIndex(imp, "/vendor/"); i != -1 {
-		imp = imp[i+len("/vendor/"):]
-	}
-	return imp
-}
-
 // ErrorInterface represent built-in error interface.
 var ErrorInterface = Interface{
 	Name: "error",
diff --git a/mockgen/model/model_test.go b/mockgen/model/model_test.go
deleted file mode 100644
index c0ea0f1a..00000000
--- a/mockgen/model/model_test.go
+++ /dev/null
@@ -1,35 +0,0 @@
-package model
-
-import (
-	"fmt"
-	"testing"
-)
-
-func TestImpPath(t *testing.T) {
-	nonVendor := "github.com/foo/bar"
-	if nonVendor != impPath(nonVendor) {
-		t.Errorf("")
-	}
-	testCases := []struct {
-		input string
-		want  string
-	}{
-		{"foo/bar", "foo/bar"},
-		{"vendor/foo/bar", "foo/bar"},
-		{"vendor/foo/vendor/bar", "bar"},
-		{"/vendor/foo/bar", "foo/bar"},
-		{"qux/vendor/foo/bar", "foo/bar"},
-		{"qux/vendor/foo/vendor/bar", "bar"},
-		{"govendor/foo", "govendor/foo"},
-		{"foo/govendor/bar", "foo/govendor/bar"},
-		{"vendors/foo", "vendors/foo"},
-		{"foo/vendors/bar", "foo/vendors/bar"},
-	}
-	for _, tc := range testCases {
-		t.Run(fmt.Sprintf("input %s", tc.input), func(t *testing.T) {
-			if got := impPath(tc.input); got != tc.want {
-				t.Errorf("got %s; want %s", got, tc.want)
-			}
-		})
-	}
-}