update kube and vendor dependencies

With kubernetes 1.18 release of client-go, signatures on methods in
generated clientsets, dynamic, metadata, and scale clients have been
modified to accept context.Context as a first argument.
Signatures of Create, Update, and Patch methods have been updated
to accept CreateOptions, UpdateOptions and PatchOptions respectively.
Signatures of Delete and DeleteCollection methods now accept
DeleteOptions by value instead of by reference.
These changes are now accommodated with this PR and client-go
and dependencies are updated to v1.18.0

Signed-off-by: Humble Chirammal <hchiramm@redhat.com>

vendor/k8s.io/gengo/args/args.go

@@ -112,7 +112,7 @@ func (g *GeneratorArgs) LoadGoBoilerplate() ([]byte, error) {
 	if err != nil {
 		return nil, err
 	}
-	b = bytes.Replace(b, []byte("YEAR"), []byte(strconv.Itoa(time.Now().Year())), -1)
+	b = bytes.Replace(b, []byte("YEAR"), []byte(strconv.Itoa(time.Now().UTC().Year())), -1)
 
 	if g.GeneratedByCommentTemplate != "" {
 		if len(b) != 0 {
@@ -159,6 +159,9 @@ func (g *GeneratorArgs) InputIncludes(p *types.Package) bool {
 		if strings.HasSuffix(d, "...") {
 			d = strings.TrimSuffix(d, "...")
 		}
+		if strings.HasPrefix(d, "./vendor/") {
+			d = strings.TrimPrefix(d, "./vendor/")
+		}
 		if strings.HasPrefix(p.Path, d) {
 			return true
 		}

vendor/k8s.io/gengo/examples/defaulter-gen/generators/defaulter.go

@@ -248,7 +248,11 @@ func Packages(context *generator.Context, arguments *args.GeneratorArgs) generat
 		shouldCreateObjectDefaulterFn := func(t *types.Type) bool {
 			if defaults, ok := existingDefaulters[t]; ok && defaults.object != nil {
 				// A default generator is defined
-				klog.V(5).Infof("  an object defaulter already exists as %s", defaults.base.Name)
+				baseTypeName := "<unknown>"
+				if defaults.base != nil {
+					baseTypeName = defaults.base.Name.String()
+				}
+				klog.V(5).Infof("  an object defaulter already exists as %s", baseTypeName)
 				return false
 			}
 			// opt-out

vendor/k8s.io/gengo/examples/import-boss/generators/import_restrict.go

@@ -33,11 +33,13 @@ import (
 	"k8s.io/gengo/generator"
 	"k8s.io/gengo/namer"
 	"k8s.io/gengo/types"
+	"sigs.k8s.io/yaml"
 
 	"k8s.io/klog"
 )
 
 const (
+	goModFile          = "go.mod"
 	importBossFileType = "import-boss"
 )
 
@@ -58,7 +60,7 @@ func DefaultNameSystem() string {
 func Packages(c *generator.Context, arguments *args.GeneratorArgs) generator.Packages {
 	pkgs := generator.Packages{}
 	c.FileTypes = map[string]generator.FileType{
-		importBossFileType: importRuleFile{},
+		importBossFileType: importRuleFile{c},
 	}
 
 	for _, p := range c.Universe {
@@ -70,6 +72,7 @@ func Packages(c *generator.Context, arguments *args.GeneratorArgs) generator.Pac
 		pkgs = append(pkgs, &generator.DefaultPackage{
 			PackageName: p.Name,
 			PackagePath: p.Path,
+			Source:      p.SourcePath,
 			// GeneratorFunc returns a list of generators. Each generator makes a
 			// single file.
 			GeneratorFunc: func(c *generator.Context) (generators []generator.Generator) {
@@ -96,10 +99,19 @@ type Rule struct {
 	ForbiddenPrefixes []string
 }
 
+type InverseRule struct {
+	Rule
+	// True if the rule is to be applied to transitive imports.
+	Transitive bool
+}
+
 type fileFormat struct {
 	CurrentImports []string
 
-	Rules []Rule
+	Rules        []Rule
+	InverseRules []InverseRule
+
+	path string
 }
 
 func readFile(path string) (*fileFormat, error) {
@@ -109,10 +121,11 @@ func readFile(path string) (*fileFormat, error) {
 	}
 
 	var current fileFormat
-	err = json.Unmarshal(currentBytes, &current)
+	err = yaml.Unmarshal(currentBytes, &current)
 	if err != nil {
 		return nil, fmt.Errorf("couldn't unmarshal %v: %v", path, err)
 	}
+	current.path = path
 	return &current, nil
 }
 
@@ -131,10 +144,12 @@ func writeFile(path string, ff *fileFormat) error {
 }
 
 // This does the actual checking, since it knows the literal destination file.
-type importRuleFile struct{}
+type importRuleFile struct {
+	context *generator.Context
+}
 
-func (importRuleFile) AssembleFile(f *generator.File, path string) error {
-	return nil
+func (irf importRuleFile) AssembleFile(f *generator.File, path string) error {
+	return irf.VerifyFile(f, path)
 }
 
 // TODO: make a flag to enable this, or expose this information in some other way.
@@ -169,62 +184,99 @@ func removeLastDir(path string) (newPath, removedDir string) {
 	return filepath.Join(filepath.Dir(dir), file), filepath.Base(dir)
 }
 
-// Keep going up a directory until we find an .import-restrictions file.
-func recursiveRead(path string) (*fileFormat, string, error) {
+// isGoModRoot checks if a directory is the root directory for a package
+// by checking for the existence of a 'go.mod' file in that directory.
+func isGoModRoot(path string) bool {
+	_, err := os.Stat(filepath.Join(filepath.Dir(path), goModFile))
+	return err == nil
+}
+
+// recursiveRead collects all '.import-restriction' files, between the current directory,
+// and the package root when Go modules are enabled, or $GOPATH/src when they are not.
+func recursiveRead(path string) ([]*fileFormat, error) {
+	restrictionFiles := make([]*fileFormat, 0)
+
 	for {
 		if _, err := os.Stat(path); err == nil {
-			ff, err := readFile(path)
-			return ff, path, err
+			rules, err := readFile(path)
+			if err != nil {
+				return nil, err
+			}
+
+			restrictionFiles = append(restrictionFiles, rules)
 		}
 
 		nextPath, removedDir := removeLastDir(path)
-		if nextPath == path || removedDir == "src" {
+		if nextPath == path || isGoModRoot(path) || removedDir == "src" {
 			break
 		}
+
 		path = nextPath
 	}
-	return nil, "", nil
+
+	return restrictionFiles, nil
 }
 
-func (importRuleFile) VerifyFile(f *generator.File, path string) error {
-	rules, actualPath, err := recursiveRead(path)
+func (irf importRuleFile) VerifyFile(f *generator.File, path string) error {
+	restrictionFiles, err := recursiveRead(filepath.Join(f.PackageSourcePath, f.Name))
 	if err != nil {
 		return fmt.Errorf("error finding rules file: %v", err)
 	}
 
-	if rules == nil {
-		// No restrictions on this directory.
-		return nil
+	if err := irf.verifyRules(restrictionFiles, f); err != nil {
+		return err
+	}
+
+	return irf.verifyInverseRules(restrictionFiles, f)
+}
+
+func (irf importRuleFile) verifyRules(restrictionFiles []*fileFormat, f *generator.File) error {
+	selectors := make([][]*regexp.Regexp, len(restrictionFiles))
+	for i, restrictionFile := range restrictionFiles {
+		for _, r := range restrictionFile.Rules {
+			re, err := regexp.Compile(r.SelectorRegexp)
+			if err != nil {
+				return fmt.Errorf("regexp `%s` in file %q doesn't compile: %v", r.SelectorRegexp, restrictionFile.path, err)
+			}
+
+			selectors[i] = append(selectors[i], re)
+		}
 	}
 
 	forbiddenImports := map[string]string{}
 	allowedMismatchedImports := []string{}
-	for _, r := range rules.Rules {
-		re, err := regexp.Compile(r.SelectorRegexp)
-		if err != nil {
-			return fmt.Errorf("regexp `%s` in file %q doesn't compile: %v", r.SelectorRegexp, actualPath, err)
-		}
-		for v := range f.Imports {
-			klog.V(4).Infof("Checking %v matches %v: %v\n", r.SelectorRegexp, v, re.MatchString(v))
-			if !re.MatchString(v) {
-				continue
-			}
-			for _, forbidden := range r.ForbiddenPrefixes {
-				klog.V(4).Infof("Checking %v against %v\n", v, forbidden)
-				if strings.HasPrefix(v, forbidden) {
-					forbiddenImports[v] = forbidden
+
+	for v := range f.Imports {
+		explicitlyAllowed := false
+
+	NextRestrictionFiles:
+		for i, rules := range restrictionFiles {
+			for j, r := range rules.Rules {
+				matching := selectors[i][j].MatchString(v)
+				klog.V(5).Infof("Checking %v matches %v: %v\n", r.SelectorRegexp, v, matching)
+				if !matching {
+					continue
 				}
-			}
-			found := false
-			for _, allowed := range r.AllowedPrefixes {
-				klog.V(4).Infof("Checking %v against %v\n", v, allowed)
-				if strings.HasPrefix(v, allowed) {
-					found = true
-					break
+				for _, forbidden := range r.ForbiddenPrefixes {
+					klog.V(4).Infof("Checking %v against %v\n", v, forbidden)
+					if strings.HasPrefix(v, forbidden) {
+						forbiddenImports[v] = forbidden
+					}
+				}
+				for _, allowed := range r.AllowedPrefixes {
+					klog.V(4).Infof("Checking %v against %v\n", v, allowed)
+					if strings.HasPrefix(v, allowed) {
+						explicitlyAllowed = true
+						break
+					}
+				}
+
+				if !explicitlyAllowed {
+					allowedMismatchedImports = append(allowedMismatchedImports, v)
+				} else {
+					klog.V(2).Infof("%v importing %v allowed by %v\n", f.PackagePath, v, restrictionFiles[i].path)
+					break NextRestrictionFiles
 				}
-			}
-			if !found {
-				allowedMismatchedImports = append(allowedMismatchedImports, v)
 			}
 		}
 	}
@@ -243,8 +295,85 @@ func (importRuleFile) VerifyFile(f *generator.File, path string) error {
 		}
 		return errors.New(errorBuilder.String())
 	}
-	if len(rules.Rules) > 0 {
-		klog.V(2).Infof("%v passes rules found in %v\n", path, actualPath)
+
+	return nil
+}
+
+// verifyInverseRules checks that all packages that import a package are allowed to import it.
+func (irf importRuleFile) verifyInverseRules(restrictionFiles []*fileFormat, f *generator.File) error {
+	// compile all Selector regex in all restriction files
+	selectors := make([][]*regexp.Regexp, len(restrictionFiles))
+	for i, restrictionFile := range restrictionFiles {
+		for _, r := range restrictionFile.InverseRules {
+			re, err := regexp.Compile(r.SelectorRegexp)
+			if err != nil {
+				return fmt.Errorf("regexp `%s` in file %q doesn't compile: %v", r.SelectorRegexp, restrictionFile.path, err)
+			}
+
+			selectors[i] = append(selectors[i], re)
+		}
+	}
+
+	directImport := map[string]bool{}
+	for _, imp := range irf.context.IncomingImports()[f.PackagePath] {
+		directImport[imp] = true
+	}
+
+	forbiddenImports := map[string]string{}
+	allowedMismatchedImports := []string{}
+
+	for _, v := range irf.context.TransitiveIncomingImports()[f.PackagePath] {
+		explicitlyAllowed := false
+
+	NextRestrictionFiles:
+		for i, rules := range restrictionFiles {
+			for j, r := range rules.InverseRules {
+				if !r.Transitive && !directImport[v] {
+					continue
+				}
+
+				re := selectors[i][j]
+				matching := re.MatchString(v)
+				klog.V(4).Infof("Checking %v matches %v (importing %v: %v\n", r.SelectorRegexp, v, f.PackagePath, matching)
+				if !matching {
+					continue
+				}
+				for _, forbidden := range r.ForbiddenPrefixes {
+					klog.V(4).Infof("Checking %v against %v\n", v, forbidden)
+					if strings.HasPrefix(v, forbidden) {
+						forbiddenImports[v] = forbidden
+					}
+				}
+				for _, allowed := range r.AllowedPrefixes {
+					klog.V(4).Infof("Checking %v against %v\n", v, allowed)
+					if strings.HasPrefix(v, allowed) {
+						explicitlyAllowed = true
+						break
+					}
+				}
+				if !explicitlyAllowed {
+					allowedMismatchedImports = append(allowedMismatchedImports, v)
+				} else {
+					klog.V(2).Infof("%v importing %v allowed by %v\n", v, f.PackagePath, restrictionFiles[i].path)
+					break NextRestrictionFiles
+				}
+			}
+		}
+	}
+
+	if len(forbiddenImports) > 0 || len(allowedMismatchedImports) > 0 {
+		var errorBuilder strings.Builder
+		for i, f := range forbiddenImports {
+			fmt.Fprintf(&errorBuilder, "(inverse): import %v has forbidden prefix %v\n", i, f)
+		}
+		if len(allowedMismatchedImports) > 0 {
+			sort.Sort(sort.StringSlice(allowedMismatchedImports))
+			fmt.Fprintf(&errorBuilder, "(inverse): the following imports did not match any allowed prefix:\n")
+			for _, i := range allowedMismatchedImports {
+				fmt.Fprintf(&errorBuilder, "  %v\n", i)
+			}
+		}
+		return errors.New(errorBuilder.String())
 	}
 
 	return nil

vendor/k8s.io/gengo/generator/default_package.go

@@ -26,6 +26,8 @@ type DefaultPackage struct {
 	PackageName string
 	// Import path of the package, and the location on disk of the package.
 	PackagePath string
+	// The location of the package on disk.
+	Source string
 
 	// Emitted at the top of every file.
 	HeaderText []byte
@@ -43,8 +45,9 @@ type DefaultPackage struct {
 	FilterFunc func(*Context, *types.Type) bool
 }
 
-func (d *DefaultPackage) Name() string { return d.PackageName }
-func (d *DefaultPackage) Path() string { return d.PackagePath }
+func (d *DefaultPackage) Name() string       { return d.PackageName }
+func (d *DefaultPackage) Path() string       { return d.PackagePath }
+func (d *DefaultPackage) SourcePath() string { return d.Source }
 
 func (d *DefaultPackage) Filter(c *Context, t *types.Type) bool {
 	if d.FilterFunc != nil {

vendor/k8s.io/gengo/generator/execute.go

@@ -233,11 +233,13 @@ func (c *Context) ExecutePackage(outDir string, p Package) error {
 		if f == nil {
 			// This is the first generator to reference this file, so start it.
 			f = &File{
-				Name:        g.Filename(),
-				FileType:    fileType,
-				PackageName: p.Name(),
-				Header:      p.Header(g.Filename()),
-				Imports:     map[string]struct{}{},
+				Name:              g.Filename(),
+				FileType:          fileType,
+				PackageName:       p.Name(),
+				PackagePath:       p.Path(),
+				PackageSourcePath: p.SourcePath(),
+				Header:            p.Header(g.Filename()),
+				Imports:           map[string]struct{}{},
 			}
 			files[f.Name] = f
 		} else {

vendor/k8s.io/gengo/generator/generator.go

@@ -31,6 +31,8 @@ type Package interface {
 	Name() string
 	// Path returns the package import path.
 	Path() string
+	// SourcePath returns the location of the package on disk.
+	SourcePath() string
 
 	// Filter should return true if this package cares about this type.
 	// Otherwise, this type will be omitted from the type ordering for
@@ -50,14 +52,16 @@ type Package interface {
 }
 
 type File struct {
-	Name        string
-	FileType    string
-	PackageName string
-	Header      []byte
-	Imports     map[string]struct{}
-	Vars        bytes.Buffer
-	Consts      bytes.Buffer
-	Body        bytes.Buffer
+	Name              string
+	FileType          string
+	PackageName       string
+	Header            []byte
+	PackagePath       string
+	PackageSourcePath string
+	Imports           map[string]struct{}
+	Vars              bytes.Buffer
+	Consts            bytes.Buffer
+	Body              bytes.Buffer
 }
 
 type FileType interface {
@@ -156,6 +160,12 @@ type Context struct {
 	// All the types, in case you want to look up something.
 	Universe types.Universe
 
+	// Incoming imports, i.e. packages importing the given package.
+	incomingImports map[string][]string
+
+	// Incoming transitive imports, i.e. the transitive closure of IncomingImports
+	incomingTransitiveImports map[string][]string
+
 	// All the user-specified packages.  This is after recursive expansion.
 	Inputs []string
 
@@ -203,11 +213,36 @@ func NewContext(b *parser.Builder, nameSystems namer.NameSystems, canonicalOrder
 	return c, nil
 }
 
+// IncomingImports returns the incoming imports for each package. The map is lazily computed.
+func (ctxt *Context) IncomingImports() map[string][]string {
+	if ctxt.incomingImports == nil {
+		incoming := map[string][]string{}
+		for _, pkg := range ctxt.Universe {
+			for imp := range pkg.Imports {
+				incoming[imp] = append(incoming[imp], pkg.Path)
+			}
+		}
+		ctxt.incomingImports = incoming
+	}
+	return ctxt.incomingImports
+}
+
+// TransitiveIncomingImports returns the transitive closure of the incoming imports for each package.
+// The map is lazily computed.
+func (ctxt *Context) TransitiveIncomingImports() map[string][]string {
+	if ctxt.incomingTransitiveImports == nil {
+		ctxt.incomingTransitiveImports = transitiveClosure(ctxt.IncomingImports())
+	}
+	return ctxt.incomingTransitiveImports
+}
+
 // AddDir adds a Go package to the context. The specified path must be a single
 // go package import path.  GOPATH, GOROOT, and the location of your go binary
 // (`which go`) will all be searched, in the normal Go fashion.
 // Deprecated. Please use AddDirectory.
 func (ctxt *Context) AddDir(path string) error {
+	ctxt.incomingImports = nil
+	ctxt.incomingTransitiveImports = nil
 	return ctxt.builder.AddDirTo(path, &ctxt.Universe)
 }
 
@@ -215,5 +250,7 @@ func (ctxt *Context) AddDir(path string) error {
 // single go package import path.  GOPATH, GOROOT, and the location of your go
 // binary (`which go`) will all be searched, in the normal Go fashion.
 func (ctxt *Context) AddDirectory(path string) (*types.Package, error) {
+	ctxt.incomingImports = nil
+	ctxt.incomingTransitiveImports = nil
 	return ctxt.builder.AddDirectoryTo(path, &ctxt.Universe)
 }

vendor/k8s.io/gengo/generator/import_tracker.go

@@ -17,6 +17,7 @@ limitations under the License.
 package generator
 
 import (
+	"go/token"
 	"strings"
 
 	"k8s.io/klog"
@@ -58,6 +59,11 @@ func golangTrackerLocalName(tracker namer.ImportTracker, t types.Name) string {
 			// This name collides with some other package
 			continue
 		}
+
+		// If the import name is a Go keyword, prefix with an underscore.
+		if token.Lookup(name).IsKeyword() {
+			name = "_" + name
+		}
 		return name
 	}
 	panic("can't find import for " + path)

vendor/k8s.io/gengo/generator/transitive_closure.go

@@ -0,0 +1,65 @@
+/*
+Copyright 2019 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package generator
+
+import "sort"
+
+type edge struct {
+	from string
+	to   string
+}
+
+func transitiveClosure(in map[string][]string) map[string][]string {
+	adj := make(map[edge]bool)
+	imports := make(map[string]struct{})
+	for from, tos := range in {
+		for _, to := range tos {
+			adj[edge{from, to}] = true
+			imports[to] = struct{}{}
+		}
+	}
+
+	// Warshal's algorithm
+	for k := range in {
+		for i := range in {
+			if !adj[edge{i, k}] {
+				continue
+			}
+			for j := range imports {
+				if adj[edge{i, j}] {
+					continue
+				}
+				if adj[edge{k, j}] {
+					adj[edge{i, j}] = true
+				}
+			}
+		}
+	}
+
+	out := make(map[string][]string, len(in))
+	for i := range in {
+		for j := range imports {
+			if adj[edge{i, j}] {
+				out[i] = append(out[i], j)
+			}
+		}
+
+		sort.Strings(out[i])
+	}
+
+	return out
+}

vendor/k8s.io/gengo/namer/order.go

@@ -43,6 +43,9 @@ func (o *Orderer) OrderUniverse(u types.Universe) []*types.Type {
 		for _, v := range p.Variables {
 			list.types = append(list.types, v)
 		}
+		for _, v := range p.Constants {
+			list.types = append(list.types, v)
+		}
 	}
 	sort.Sort(list)
 	return list.types

vendor/k8s.io/gengo/parser/parse.go

@@ -227,12 +227,16 @@ func (b *Builder) AddDirRecursive(dir string) error {
 		klog.Warningf("Ignoring directory %v: %v", dir, err)
 	}
 
-	// filepath.Walk includes the root dir, but we already did that, so we'll
-	// remove that prefix and rebuild a package import path.
-	prefix := b.buildPackages[dir].Dir
+	// filepath.Walk does not follow symlinks. We therefore evaluate symlinks and use that with
+	// filepath.Walk.
+	realPath, err := filepath.EvalSymlinks(b.buildPackages[dir].Dir)
+	if err != nil {
+		return err
+	}
+
 	fn := func(filePath string, info os.FileInfo, err error) error {
 		if info != nil && info.IsDir() {
-			rel := filepath.ToSlash(strings.TrimPrefix(filePath, prefix))
+			rel := filepath.ToSlash(strings.TrimPrefix(filePath, realPath))
 			if rel != "" {
 				// Make a pkg path.
 				pkg := path.Join(string(canonicalizeImportPath(b.buildPackages[dir].ImportPath)), rel)
@@ -245,7 +249,7 @@ func (b *Builder) AddDirRecursive(dir string) error {
 		}
 		return nil
 	}
-	if err := filepath.Walk(b.buildPackages[dir].Dir, fn); err != nil {
+	if err := filepath.Walk(realPath, fn); err != nil {
 		return err
 	}
 	return nil
@@ -544,6 +548,10 @@ func (b *Builder) findTypesIn(pkgPath importPathString, u *types.Universe) error
 		if ok && !tv.IsField() {
 			b.addVariable(*u, nil, tv)
 		}
+		tconst, ok := obj.(*tc.Const)
+		if ok {
+			b.addConstant(*u, nil, tconst)
+		}
 	}
 
 	importedPkgs := []string{}
@@ -774,7 +782,10 @@ func (b *Builder) walkType(u types.Universe, useName *types.Name, in tc.Type) *t
 				if out.Methods == nil {
 					out.Methods = map[string]*types.Type{}
 				}
-				out.Methods[t.Method(i).Name()] = b.walkType(u, nil, t.Method(i).Type())
+				method := t.Method(i)
+				mt := b.walkType(u, nil, method.Type())
+				mt.CommentLines = splitLines(b.priorCommentLines(method.Pos(), 1).Text())
+				out.Methods[method.Name()] = mt
 			}
 		}
 		return out
@@ -811,6 +822,17 @@ func (b *Builder) addVariable(u types.Universe, useName *types.Name, in *tc.Var)
 	return out
 }
 
+func (b *Builder) addConstant(u types.Universe, useName *types.Name, in *tc.Const) *types.Type {
+	name := tcVarNameToName(in.String())
+	if useName != nil {
+		name = *useName
+	}
+	out := u.Constant(name)
+	out.Kind = types.DeclarationOf
+	out.Underlying = b.walkType(u, nil, in.Type())
+	return out
+}
+
 // canonicalizeImportPath takes an import path and returns the actual package.
 // It doesn't support nested vendoring.
 func canonicalizeImportPath(importPath string) importPathString {

vendor/k8s.io/gengo/types/types.go

@@ -135,6 +135,10 @@ type Package struct {
 	// package name).
 	Variables map[string]*Type
 
+	// Global constants within this package, indexed by their name (*not* including
+	// package name).
+	Constants map[string]*Type
+
 	// Packages imported by this package, indexed by (canonicalized)
 	// package path.
 	Imports map[string]*Package
@@ -193,6 +197,20 @@ func (p *Package) Variable(varName string) *Type {
 	return t
 }
 
+// Constant gets the given constant Type in this Package. If the constant is
+// not already defined, this will add it. If a constant is added, it's the caller's
+// responsibility to finish construction of the constant by setting Underlying
+// to the correct type.
+func (p *Package) Constant(constName string) *Type {
+	if t, ok := p.Constants[constName]; ok {
+		return t
+	}
+	t := &Type{Name: Name{Package: p.Path, Name: constName}}
+	t.Kind = DeclarationOf
+	p.Constants[constName] = t
+	return t
+}
+
 // HasImport returns true if p imports packageName. Package names include the
 // package directory.
 func (p *Package) HasImport(packageName string) bool {
@@ -229,6 +247,14 @@ func (u Universe) Variable(n Name) *Type {
 	return u.Package(n.Package).Variable(n.Name)
 }
 
+// Constant returns the canonical constant for the given fully-qualified name.
+// If a non-existing constant is requested, this will create (a marker for) it.
+// If a marker is created, it's the caller's responsibility to finish
+// construction of the constant by setting Underlying to the correct type.
+func (u Universe) Constant(n Name) *Type {
+	return u.Package(n.Package).Constant(n.Name)
+}
+
 // AddImports registers import lines for packageName. May be called multiple times.
 // You are responsible for canonicalizing all package paths.
 func (u Universe) AddImports(packagePath string, importPaths ...string) {
@@ -251,6 +277,7 @@ func (u Universe) Package(packagePath string) *Package {
 		Types:     map[string]*Type{},
 		Functions: map[string]*Type{},
 		Variables: map[string]*Type{},
+		Constants: map[string]*Type{},
 		Imports:   map[string]*Package{},
 	}
 	u[packagePath] = p