Source file src/go/build/deps_test.go

     1  // Copyright 2022 The Go Authors. All rights reserved.
     2  // Use of this source code is governed by a BSD-style
     3  // license that can be found in the LICENSE file.
     4  
     5  // This file exercises the import parser but also checks that
     6  // some low-level packages do not have new dependencies added.
     7  
     8  package build
     9  
    10  import (
    11  	"bytes"
    12  	"fmt"
    13  	"go/token"
    14  	"internal/dag"
    15  	"internal/testenv"
    16  	"io/fs"
    17  	"os"
    18  	"path/filepath"
    19  	"slices"
    20  	"strings"
    21  	"testing"
    22  )
    23  
    24  // depsRules defines the expected dependencies between packages in
    25  // the Go source tree. It is a statement of policy.
    26  //
    27  // DO NOT CHANGE THIS DATA TO FIX BUILDS.
    28  // Existing packages should not have their constraints relaxed
    29  // without prior discussion.
    30  // Negative assertions should almost never be removed.
    31  //
    32  // "a < b" means package b can import package a.
    33  //
    34  // See `go doc internal/dag` for the full syntax.
    35  //
    36  // All-caps names are pseudo-names for specific points
    37  // in the dependency lattice.
    38  var depsRules = `
    39  	# No dependencies allowed for any of these packages.
    40  	NONE
    41  	< unsafe
    42  	< cmp,
    43  	  container/list,
    44  	  container/ring,
    45  	  internal/byteorder,
    46  	  internal/cfg,
    47  	  internal/coverage,
    48  	  internal/coverage/rtcov,
    49  	  internal/coverage/uleb128,
    50  	  internal/coverage/calloc,
    51  	  internal/cpu,
    52  	  internal/goarch,
    53  	  internal/godebugs,
    54  	  internal/goexperiment,
    55  	  internal/goos,
    56  	  internal/goversion,
    57  	  internal/nettrace,
    58  	  internal/platform,
    59  	  internal/profilerecord,
    60  	  internal/syslist,
    61  	  internal/trace/tracev2,
    62  	  internal/trace/traceviewer/format,
    63  	  log/internal,
    64  	  math/bits,
    65  	  structs,
    66  	  unicode,
    67  	  unicode/utf8,
    68  	  unicode/utf16;
    69  
    70  	internal/goarch < internal/abi;
    71  	internal/byteorder, internal/cpu, internal/goarch < internal/chacha8rand;
    72  
    73  	# RUNTIME is the core runtime group of packages, all of them very light-weight.
    74  	internal/abi,
    75  	internal/chacha8rand,
    76  	internal/coverage/rtcov,
    77  	internal/cpu,
    78  	internal/goarch,
    79  	internal/godebugs,
    80  	internal/goexperiment,
    81  	internal/goos,
    82  	internal/profilerecord,
    83  	internal/trace/tracev2,
    84  	math/bits,
    85  	structs
    86  	< internal/bytealg
    87  	< internal/stringslite
    88  	< internal/itoa
    89  	< internal/unsafeheader
    90  	< internal/race
    91  	< internal/msan
    92  	< internal/asan
    93  	< internal/runtime/sys
    94  	< internal/runtime/syscall
    95  	< internal/runtime/atomic
    96  	< internal/runtime/exithook
    97  	< internal/runtime/gc
    98  	< internal/runtime/math
    99  	< internal/runtime/maps
   100  	< internal/runtime/strconv
   101  	< internal/runtime/cgroup
   102  	< runtime
   103  	< sync/atomic
   104  	< internal/sync
   105  	< weak
   106  	< internal/synctest
   107  	< sync
   108  	< internal/bisect
   109  	< internal/godebug
   110  	< internal/reflectlite
   111  	< errors
   112  	< internal/oserror;
   113  
   114  	cmp, runtime, math/bits
   115  	< iter
   116  	< maps, slices;
   117  
   118  	internal/oserror, maps, slices
   119  	< RUNTIME;
   120  
   121  	RUNTIME
   122  	< sort
   123  	< container/heap
   124  	< unique;
   125  
   126  	RUNTIME
   127  	< io;
   128  
   129  	RUNTIME
   130  	< arena;
   131  
   132  	syscall !< io;
   133  	reflect !< sort;
   134  
   135  	RUNTIME, unicode/utf8
   136  	< path;
   137  
   138  	unicode !< path;
   139  
   140  	# SYSCALL is RUNTIME plus the packages necessary for basic system calls.
   141  	RUNTIME, unicode/utf8, unicode/utf16, internal/synctest
   142  	< internal/syscall/windows/sysdll, syscall/js
   143  	< syscall
   144  	< internal/syscall/unix, internal/syscall/windows, internal/syscall/windows/registry
   145  	< internal/syscall/execenv
   146  	< SYSCALL;
   147  
   148  	# TIME is SYSCALL plus the core packages about time, including context.
   149  	SYSCALL
   150  	< time/tzdata
   151  	< time
   152  	< context
   153  	< TIME;
   154  
   155  	TIME, io, path, slices
   156  	< io/fs;
   157  
   158  	# MATH is RUNTIME plus the basic math packages.
   159  	RUNTIME
   160  	< math
   161  	< MATH;
   162  
   163  	unicode !< math;
   164  
   165  	MATH
   166  	< math/cmplx;
   167  
   168  	MATH
   169  	< math/rand, math/rand/v2;
   170  
   171  	MATH
   172  	< runtime/metrics;
   173  
   174  	MATH, unicode/utf8
   175  	< strconv;
   176  
   177  	unicode !< strconv;
   178  
   179  	# STR is basic string and buffer manipulation.
   180  	RUNTIME, io, unicode/utf8, unicode/utf16, unicode
   181  	< bytes, strings
   182  	< bufio;
   183  
   184  	bufio, path, strconv
   185  	< STR;
   186  
   187  	# OS is basic OS access, including helpers (path/filepath, os/exec, etc).
   188  	# OS includes string routines, but those must be layered above package os.
   189  	# OS does not include reflection.
   190  	io/fs
   191  	< internal/testlog
   192  	< internal/poll
   193  	< internal/filepathlite
   194  	< os
   195  	< os/signal;
   196  
   197  	io/fs
   198  	< embed;
   199  
   200  	unicode, fmt !< net, os, os/signal;
   201  
   202  	os/signal, internal/filepathlite, STR
   203  	< path/filepath
   204  	< io/ioutil;
   205  
   206  	path/filepath, internal/godebug < os/exec;
   207  
   208  	io/ioutil, os/exec, os/signal
   209  	< OS;
   210  
   211  	reflect !< OS;
   212  
   213  	OS
   214  	< golang.org/x/sys/cpu;
   215  
   216  	# FMT is OS (which includes string routines) plus reflect and fmt.
   217  	# It does not include package log, which should be avoided in core packages.
   218  	arena, strconv, unicode
   219  	< reflect;
   220  
   221  	os, reflect
   222  	< internal/fmtsort
   223  	< fmt;
   224  
   225  	OS, fmt
   226  	< FMT;
   227  
   228  	log !< FMT;
   229  
   230  	# Misc packages needing only FMT.
   231  	FMT
   232  	< html,
   233  	  internal/dag,
   234  	  internal/goroot,
   235  	  internal/types/errors,
   236  	  mime/quotedprintable,
   237  	  net/internal/socktest,
   238  	  net/url,
   239  	  runtime/trace,
   240  	  text/scanner,
   241  	  text/tabwriter;
   242  
   243  	io, reflect
   244  	< internal/saferio;
   245  
   246  	# encodings
   247  	# core ones do not use fmt.
   248  	io, strconv, slices
   249  	< encoding, encoding/base32, encoding/base64;
   250  
   251  	encoding, reflect
   252  	< encoding/binary;
   253  
   254  	FMT, encoding < flag;
   255  
   256  	fmt !< encoding/base32, encoding/base64;
   257  
   258  	FMT, encoding, encoding/base32, encoding/base64, encoding/binary,
   259  	internal/saferio
   260  	< encoding/ascii85, encoding/csv, encoding/gob, encoding/hex,
   261  	  encoding/pem, encoding/xml, mime;
   262  
   263  	STR, errors
   264  	< encoding/json/internal
   265  	< encoding/json/internal/jsonflags
   266  	< encoding/json/internal/jsonopts
   267  	< encoding/json/internal/jsonwire
   268  	< encoding/json/jsontext;
   269  
   270  	FMT,
   271  	encoding/hex,
   272  	encoding/base32,
   273  	encoding/base64,
   274  	encoding/binary,
   275  	encoding/json/jsontext,
   276  	encoding/json/internal,
   277  	encoding/json/internal/jsonflags,
   278  	encoding/json/internal/jsonopts,
   279  	encoding/json/internal/jsonwire
   280  	< encoding/json/v2
   281  	< encoding/json;
   282  
   283  	# hashes
   284  	io
   285  	< hash
   286  	< hash/adler32, hash/crc32, hash/crc64, hash/fnv;
   287  
   288  	# math/big
   289  	FMT, math/rand
   290  	< math/big;
   291  
   292  	# compression
   293  	FMT, encoding/binary, hash/adler32, hash/crc32, sort
   294  	< compress/bzip2, compress/flate, compress/lzw, internal/zstd
   295  	< archive/zip, compress/gzip, compress/zlib;
   296  
   297  	# templates
   298  	FMT
   299  	< text/template/parse;
   300  
   301  	net/url, text/template/parse
   302  	< text/template
   303  	< internal/lazytemplate;
   304  
   305  	# regexp
   306  	FMT, sort
   307  	< regexp/syntax
   308  	< regexp
   309  	< internal/lazyregexp;
   310  
   311  	encoding/json, html, text/template, regexp
   312  	< html/template;
   313  
   314  	# suffix array
   315  	encoding/binary, regexp
   316  	< index/suffixarray;
   317  
   318  	# executable parsing
   319  	FMT, encoding/binary, compress/zlib, internal/saferio, internal/zstd, sort
   320  	< runtime/debug
   321  	< debug/dwarf
   322  	< debug/elf, debug/gosym, debug/macho, debug/pe, debug/plan9obj, internal/xcoff
   323  	< debug/buildinfo
   324  	< DEBUG;
   325  
   326  	# go parser and friends.
   327  	FMT, sort
   328  	< internal/gover
   329  	< go/version
   330  	< go/token
   331  	< go/scanner
   332  	< go/ast
   333  	< go/internal/typeparams;
   334  
   335  	FMT
   336  	< go/build/constraint;
   337  
   338  	FMT, sort
   339  	< go/doc/comment;
   340  
   341  	go/internal/typeparams, go/build/constraint
   342  	< go/parser;
   343  
   344  	go/doc/comment, go/parser, text/tabwriter
   345  	< go/printer
   346  	< go/format;
   347  
   348  	math/big, go/token
   349  	< go/constant;
   350  
   351  	FMT, internal/goexperiment
   352  	< internal/buildcfg;
   353  
   354  	container/heap, go/constant, go/parser, internal/buildcfg, internal/goversion, internal/types/errors
   355  	< go/types;
   356  
   357  	# The vast majority of standard library packages should not be resorting to regexp.
   358  	# go/types is a good chokepoint. It shouldn't use regexp, nor should anything
   359  	# that is low-enough level to be used by go/types.
   360  	regexp !< go/types;
   361  
   362  	go/doc/comment, go/parser, internal/lazyregexp, text/template
   363  	< go/doc;
   364  
   365  	go/build/constraint, go/doc, go/parser, internal/buildcfg, internal/goroot, internal/goversion, internal/platform, internal/syslist
   366  	< go/build;
   367  
   368  	# databases
   369  	FMT
   370  	< database/sql/internal
   371  	< database/sql/driver;
   372  
   373  	database/sql/driver, math/rand/v2 < database/sql;
   374  
   375  	# images
   376  	FMT, compress/lzw, compress/zlib
   377  	< image/color
   378  	< image, image/color/palette
   379  	< image/internal/imageutil
   380  	< image/draw
   381  	< image/gif, image/jpeg, image/png;
   382  
   383  	# cgo, delayed as long as possible.
   384  	# If you add a dependency on CGO, you must add the package
   385  	# to cgoPackages in cmd/dist/test.go as well.
   386  	RUNTIME
   387  	< C
   388  	< runtime/cgo
   389  	< CGO
   390  	< runtime/msan, runtime/asan;
   391  
   392  	# runtime/race
   393  	NONE < runtime/race/internal/amd64v1;
   394  	NONE < runtime/race/internal/amd64v3;
   395  	CGO, runtime/race/internal/amd64v1, runtime/race/internal/amd64v3 < runtime/race;
   396  
   397  	# Bulk of the standard library must not use cgo.
   398  	# The prohibition stops at net and os/user.
   399  	C !< fmt, go/types, CRYPTO-MATH, log/slog;
   400  
   401  	CGO, OS
   402  	< plugin;
   403  
   404  	CGO, FMT
   405  	< os/user
   406  	< archive/tar;
   407  
   408  	sync
   409  	< internal/singleflight;
   410  
   411  	os
   412  	< golang.org/x/net/dns/dnsmessage,
   413  	  golang.org/x/net/lif;
   414  
   415  	internal/bytealg, internal/itoa, math/bits, slices, strconv, unique
   416  	< net/netip;
   417  
   418  	os, net/netip
   419  	< internal/routebsd;
   420  
   421  	# net is unavoidable when doing any networking,
   422  	# so large dependencies must be kept out.
   423  	# This is a long-looking list but most of these
   424  	# are small with few dependencies.
   425  	CGO,
   426  	golang.org/x/net/dns/dnsmessage,
   427  	golang.org/x/net/lif,
   428  	internal/godebug,
   429  	internal/nettrace,
   430  	internal/poll,
   431  	internal/routebsd,
   432  	internal/singleflight,
   433  	net/netip,
   434  	os,
   435  	sort
   436  	< net;
   437  
   438  	fmt, unicode !< net;
   439  	math/rand !< net; # net uses runtime instead
   440  
   441  	# NET is net plus net-helper packages.
   442  	FMT, net
   443  	< net/textproto;
   444  
   445  	mime, net/textproto, net/url
   446  	< NET;
   447  
   448  	# logging - most packages should not import; http and up is allowed
   449  	FMT, log/internal
   450  	< log;
   451  
   452  	log, log/slog !< crypto/tls, database/sql, go/importer, testing;
   453  
   454  	FMT, log, net
   455  	< log/syslog;
   456  
   457  	RUNTIME
   458  	< log/slog/internal, log/slog/internal/buffer;
   459  
   460  	FMT,
   461  	encoding, encoding/json,
   462  	log, log/internal,
   463  	log/slog/internal, log/slog/internal/buffer,
   464  	slices
   465  	< log/slog
   466  	< log/slog/internal/slogtest, log/slog/internal/benchmarks;
   467  
   468  	NET, log
   469  	< net/mail;
   470  
   471  	# FIPS is the FIPS 140 module.
   472  	# It must not depend on external crypto packages.
   473  	# Package hash is ok as it's only the interface.
   474  	# See also fips140deps.AllowedInternalPackages.
   475  
   476  	io, math/rand/v2 < crypto/internal/randutil;
   477  
   478  	STR < crypto/internal/impl;
   479  
   480  	OS < crypto/internal/sysrand
   481  	< crypto/internal/entropy;
   482  
   483  	internal/byteorder < crypto/internal/fips140deps/byteorder;
   484  	internal/cpu, internal/goarch < crypto/internal/fips140deps/cpu;
   485  	internal/godebug < crypto/internal/fips140deps/godebug;
   486  
   487  	STR, hash,
   488  	crypto/internal/impl,
   489  	crypto/internal/entropy,
   490  	crypto/internal/randutil,
   491  	crypto/internal/fips140deps/byteorder,
   492  	crypto/internal/fips140deps/cpu,
   493  	crypto/internal/fips140deps/godebug
   494  	< crypto/internal/fips140
   495  	< crypto/internal/fips140/alias
   496  	< crypto/internal/fips140/subtle
   497  	< crypto/internal/fips140/sha256
   498  	< crypto/internal/fips140/sha512
   499  	< crypto/internal/fips140/sha3
   500  	< crypto/internal/fips140/hmac
   501  	< crypto/internal/fips140/check
   502  	< crypto/internal/fips140/pbkdf2
   503  	< crypto/internal/fips140/aes
   504  	< crypto/internal/fips140/drbg
   505  	< crypto/internal/fips140/aes/gcm
   506  	< crypto/internal/fips140/hkdf
   507  	< crypto/internal/fips140/mlkem
   508  	< crypto/internal/fips140/ssh
   509  	< crypto/internal/fips140/tls12
   510  	< crypto/internal/fips140/tls13
   511  	< crypto/internal/fips140/bigmod
   512  	< crypto/internal/fips140/nistec/fiat
   513  	< crypto/internal/fips140/nistec
   514  	< crypto/internal/fips140/ecdh
   515  	< crypto/internal/fips140/ecdsa
   516  	< crypto/internal/fips140/edwards25519/field
   517  	< crypto/internal/fips140/edwards25519
   518  	< crypto/internal/fips140/ed25519
   519  	< crypto/internal/fips140/rsa
   520  	< FIPS < crypto/fips140;
   521  
   522  	crypto !< FIPS;
   523  
   524  	# CRYPTO is core crypto algorithms - no cgo, fmt, net.
   525  	# Mostly wrappers around the FIPS module.
   526  
   527  	NONE < crypto/internal/boring/sig, crypto/internal/boring/syso;
   528  	sync/atomic < crypto/internal/boring/bcache;
   529  
   530  	FIPS, internal/godebug, embed,
   531  	crypto/internal/boring/sig,
   532  	crypto/internal/boring/syso,
   533  	crypto/internal/boring/bcache
   534  	< crypto/internal/fips140only
   535  	< crypto
   536  	< crypto/subtle
   537  	< crypto/sha3
   538  	< crypto/internal/fips140hash
   539  	< crypto/cipher
   540  	< crypto/internal/boring
   541  	< crypto/boring
   542  	< crypto/aes,
   543  	  crypto/des,
   544  	  crypto/rc4,
   545  	  crypto/md5,
   546  	  crypto/sha1,
   547  	  crypto/sha256,
   548  	  crypto/sha512,
   549  	  crypto/hmac,
   550  	  crypto/hkdf,
   551  	  crypto/pbkdf2,
   552  	  crypto/ecdh,
   553  	  crypto/mlkem
   554  	< CRYPTO;
   555  
   556  	CGO, fmt, net !< CRYPTO;
   557  
   558  	# CRYPTO-MATH is crypto that exposes math/big APIs - no cgo, net; fmt now ok.
   559  
   560  	CRYPTO, FMT, math/big
   561  	< crypto/internal/boring/bbig
   562  	< crypto/internal/fips140cache
   563  	< crypto/rand
   564  	< crypto/ed25519 # depends on crypto/rand.Reader
   565  	< encoding/asn1
   566  	< golang.org/x/crypto/cryptobyte/asn1
   567  	< golang.org/x/crypto/cryptobyte
   568  	< crypto/dsa, crypto/elliptic, crypto/rsa
   569  	< crypto/ecdsa
   570  	< CRYPTO-MATH;
   571  
   572  	CGO, net !< CRYPTO-MATH;
   573  
   574  	# TLS, Prince of Dependencies.
   575  
   576  	crypto/fips140, sync/atomic < crypto/tls/internal/fips140tls;
   577  
   578  	crypto/internal/boring/sig, crypto/tls/internal/fips140tls < crypto/tls/fipsonly;
   579  
   580  	CRYPTO, golang.org/x/sys/cpu, encoding/binary, reflect
   581  	< golang.org/x/crypto/internal/alias
   582  	< golang.org/x/crypto/internal/subtle
   583  	< golang.org/x/crypto/chacha20
   584  	< golang.org/x/crypto/internal/poly1305
   585  	< golang.org/x/crypto/chacha20poly1305;
   586  
   587  	CRYPTO-MATH, NET, container/list, encoding/hex, encoding/pem,
   588  	golang.org/x/crypto/chacha20poly1305, crypto/tls/internal/fips140tls
   589  	< crypto/internal/hpke
   590  	< crypto/x509/internal/macos
   591  	< crypto/x509/pkix
   592  	< crypto/x509
   593  	< crypto/tls;
   594  
   595  	# crypto-aware packages
   596  
   597  	DEBUG, go/build, go/types, text/scanner, crypto/sha256
   598  	< internal/pkgbits, internal/exportdata
   599  	< go/internal/gcimporter, go/internal/gccgoimporter, go/internal/srcimporter
   600  	< go/importer;
   601  
   602  	NET, crypto/rand, mime/quotedprintable
   603  	< mime/multipart;
   604  
   605  	crypto/tls
   606  	< net/smtp;
   607  
   608  	crypto/rand
   609  	< hash/maphash; # for purego implementation
   610  
   611  	# HTTP, King of Dependencies.
   612  
   613  	FMT
   614  	< golang.org/x/net/http2/hpack
   615  	< net/http/internal, net/http/internal/ascii, net/http/internal/testcert;
   616  
   617  	FMT, NET, container/list, encoding/binary, log
   618  	< golang.org/x/text/transform
   619  	< golang.org/x/text/unicode/norm
   620  	< golang.org/x/text/unicode/bidi
   621  	< golang.org/x/text/secure/bidirule
   622  	< golang.org/x/net/idna
   623  	< golang.org/x/net/http/httpguts, golang.org/x/net/http/httpproxy;
   624  
   625  	NET, crypto/tls
   626  	< net/http/httptrace;
   627  
   628  	compress/gzip,
   629  	golang.org/x/net/http/httpguts,
   630  	golang.org/x/net/http/httpproxy,
   631  	golang.org/x/net/http2/hpack,
   632  	net/http/internal,
   633  	net/http/internal/ascii,
   634  	net/http/internal/testcert,
   635  	net/http/httptrace,
   636  	mime/multipart,
   637  	log
   638  	< net/http/internal/httpcommon
   639  	< net/http;
   640  
   641  	# HTTP-aware packages
   642  
   643  	encoding/json, net/http
   644  	< expvar;
   645  
   646  	net/http, net/http/internal/ascii
   647  	< net/http/cookiejar, net/http/httputil;
   648  
   649  	net/http, flag
   650  	< net/http/httptest;
   651  
   652  	net/http, regexp
   653  	< net/http/cgi
   654  	< net/http/fcgi;
   655  
   656  	# Profiling
   657  	FMT, compress/gzip, encoding/binary, sort, text/tabwriter
   658  	< runtime/pprof;
   659  
   660  	OS, compress/gzip, internal/lazyregexp
   661  	< internal/profile;
   662  
   663  	html, internal/profile, net/http, runtime/pprof, runtime/trace
   664  	< net/http/pprof;
   665  
   666  	# RPC
   667  	encoding/gob, encoding/json, go/token, html/template, net/http
   668  	< net/rpc
   669  	< net/rpc/jsonrpc;
   670  
   671  	# System Information
   672  	bufio, bytes, internal/cpu, io, os, strings, sync
   673  	< internal/sysinfo;
   674  
   675  	# Test-only
   676  	log
   677  	< testing/iotest
   678  	< testing/fstest;
   679  
   680  	FMT, flag, math/rand
   681  	< testing/quick;
   682  
   683  	FMT, DEBUG, flag, runtime/trace, internal/sysinfo, math/rand
   684  	< testing;
   685  
   686  	log/slog, testing
   687  	< testing/slogtest;
   688  
   689  	FMT, crypto/sha256, encoding/binary, encoding/json,
   690  	go/ast, go/parser, go/token,
   691  	internal/godebug, math/rand, encoding/hex
   692  	< internal/fuzz;
   693  
   694  	OS, flag, testing, internal/cfg, internal/platform, internal/goroot
   695  	< internal/testenv;
   696  
   697  	OS, encoding/base64
   698  	< internal/obscuretestdata;
   699  
   700  	CGO, OS, fmt
   701  	< internal/testpty;
   702  
   703  	NET, testing, math/rand
   704  	< golang.org/x/net/nettest;
   705  
   706  	syscall
   707  	< os/exec/internal/fdtest;
   708  
   709  	FMT, sort
   710  	< internal/diff;
   711  
   712  	FMT
   713  	< internal/txtar;
   714  
   715  	internal/synctest, testing
   716  	< testing/synctest;
   717  
   718  	testing
   719  	< internal/testhash;
   720  
   721  	CRYPTO-MATH, testing, internal/testenv, internal/testhash, encoding/json
   722  	< crypto/internal/cryptotest;
   723  
   724  	CGO, FMT
   725  	< crypto/internal/sysrand/internal/seccomp;
   726  
   727  	FIPS
   728  	< crypto/internal/fips140/check/checktest;
   729  
   730  	# v2 execution trace parser.
   731  	FMT, io, internal/trace/tracev2
   732  	< internal/trace/version;
   733  
   734  	FMT, encoding/binary, internal/trace/version
   735  	< internal/trace/raw;
   736  
   737  	FMT, internal/trace/version, io, sort, encoding/binary
   738  	< internal/trace/internal/tracev1;
   739  
   740  	FMT, encoding/binary, internal/trace/version, internal/trace/internal/tracev1, container/heap, math/rand
   741  	< internal/trace;
   742  
   743  	regexp, internal/trace, internal/trace/raw, internal/txtar
   744  	< internal/trace/testtrace;
   745  
   746  	regexp, internal/txtar, internal/trace, internal/trace/raw
   747  	< internal/trace/internal/testgen;
   748  
   749  	# cmd/trace dependencies.
   750  	FMT,
   751  	embed,
   752  	encoding/json,
   753  	html/template,
   754  	internal/profile,
   755  	internal/trace,
   756  	internal/trace/traceviewer/format,
   757  	net/http
   758  	< internal/trace/traceviewer;
   759  
   760  	# Coverage.
   761  	FMT, hash/fnv, encoding/binary, regexp, sort, text/tabwriter,
   762  	internal/coverage, internal/coverage/uleb128
   763  	< internal/coverage/cmerge,
   764  	  internal/coverage/pods,
   765  	  internal/coverage/slicereader,
   766  	  internal/coverage/slicewriter;
   767  
   768  	internal/coverage/slicereader, internal/coverage/slicewriter
   769  	< internal/coverage/stringtab
   770  	< internal/coverage/decodecounter, internal/coverage/decodemeta,
   771  	  internal/coverage/encodecounter, internal/coverage/encodemeta;
   772  
   773  	internal/coverage/cmerge
   774  	< internal/coverage/cformat;
   775  
   776  	internal/coverage, crypto/sha256, FMT
   777  	< cmd/internal/cov/covcmd;
   778  
   779  	encoding/json,
   780  	runtime/debug,
   781  	internal/coverage/calloc,
   782  	internal/coverage/cformat,
   783  	internal/coverage/decodecounter, internal/coverage/decodemeta,
   784  	internal/coverage/encodecounter, internal/coverage/encodemeta,
   785  	internal/coverage/pods
   786  	< internal/coverage/cfile
   787  	< runtime/coverage;
   788  
   789  	internal/coverage/cfile, internal/fuzz, internal/testlog, runtime/pprof, regexp
   790  	< testing/internal/testdeps;
   791  
   792  	# Test-only packages can have anything they want
   793  	FMT, compress/gzip, embed, encoding/binary < encoding/json/internal/jsontest;
   794  	CGO, internal/syscall/unix < net/internal/cgotest;
   795  	FMT < math/big/internal/asmgen;
   796  
   797  	FMT, testing < internal/cgrouptest;
   798  `
   799  
   800  // listStdPkgs returns the same list of packages as "go list std".
   801  func listStdPkgs(goroot string) ([]string, error) {
   802  	// Based on cmd/go's matchPackages function.
   803  	var pkgs []string
   804  
   805  	src := filepath.Join(goroot, "src") + string(filepath.Separator)
   806  	walkFn := func(path string, d fs.DirEntry, err error) error {
   807  		if err != nil || !d.IsDir() || path == src {
   808  			return nil
   809  		}
   810  
   811  		base := filepath.Base(path)
   812  		if strings.HasPrefix(base, ".") || strings.HasPrefix(base, "_") || base == "testdata" {
   813  			return filepath.SkipDir
   814  		}
   815  
   816  		name := filepath.ToSlash(path[len(src):])
   817  		if name == "builtin" || name == "cmd" {
   818  			return filepath.SkipDir
   819  		}
   820  
   821  		pkgs = append(pkgs, strings.TrimPrefix(name, "vendor/"))
   822  		return nil
   823  	}
   824  	if err := filepath.WalkDir(src, walkFn); err != nil {
   825  		return nil, err
   826  	}
   827  	return pkgs, nil
   828  }
   829  
   830  func TestDependencies(t *testing.T) {
   831  	testenv.MustHaveSource(t)
   832  
   833  	ctxt := Default
   834  	all, err := listStdPkgs(ctxt.GOROOT)
   835  	if err != nil {
   836  		t.Fatal(err)
   837  	}
   838  	slices.Sort(all)
   839  
   840  	sawImport := map[string]map[string]bool{} // from package => to package => true
   841  	policy := depsPolicy(t)
   842  
   843  	for _, pkg := range all {
   844  		imports, err := findImports(pkg)
   845  		if err != nil {
   846  			t.Error(err)
   847  			continue
   848  		}
   849  		if sawImport[pkg] == nil {
   850  			sawImport[pkg] = map[string]bool{}
   851  		}
   852  		var bad []string
   853  		for _, imp := range imports {
   854  			sawImport[pkg][imp] = true
   855  			if !policy.HasEdge(pkg, imp) {
   856  				bad = append(bad, imp)
   857  			}
   858  		}
   859  		if bad != nil {
   860  			t.Errorf("unexpected dependency: %s imports %v", pkg, bad)
   861  		}
   862  	}
   863  }
   864  
   865  var buildIgnore = []byte("\n//go:build ignore")
   866  
   867  func findImports(pkg string) ([]string, error) {
   868  	vpkg := pkg
   869  	if strings.HasPrefix(pkg, "golang.org") {
   870  		vpkg = "vendor/" + pkg
   871  	}
   872  	dir := filepath.Join(Default.GOROOT, "src", vpkg)
   873  	files, err := os.ReadDir(dir)
   874  	if err != nil {
   875  		return nil, err
   876  	}
   877  	var imports []string
   878  	var haveImport = map[string]bool{}
   879  	if pkg == "crypto/internal/boring" {
   880  		haveImport["C"] = true // kludge: prevent C from appearing in crypto/internal/boring imports
   881  	}
   882  	fset := token.NewFileSet()
   883  	for _, file := range files {
   884  		name := file.Name()
   885  		if name == "slice_go14.go" || name == "slice_go18.go" {
   886  			// These files are for compiler bootstrap with older versions of Go and not built in the standard build.
   887  			continue
   888  		}
   889  		if !strings.HasSuffix(name, ".go") || strings.HasSuffix(name, "_test.go") {
   890  			continue
   891  		}
   892  		info := fileInfo{
   893  			name: filepath.Join(dir, name),
   894  			fset: fset,
   895  		}
   896  		f, err := os.Open(info.name)
   897  		if err != nil {
   898  			return nil, err
   899  		}
   900  		err = readGoInfo(f, &info)
   901  		f.Close()
   902  		if err != nil {
   903  			return nil, fmt.Errorf("reading %v: %v", name, err)
   904  		}
   905  		if info.parsed.Name.Name == "main" {
   906  			continue
   907  		}
   908  		if bytes.Contains(info.header, buildIgnore) {
   909  			continue
   910  		}
   911  		for _, imp := range info.imports {
   912  			path := imp.path
   913  			if !haveImport[path] {
   914  				haveImport[path] = true
   915  				imports = append(imports, path)
   916  			}
   917  		}
   918  	}
   919  	slices.Sort(imports)
   920  	return imports, nil
   921  }
   922  
   923  // depsPolicy returns a map m such that m[p][d] == true when p can import d.
   924  func depsPolicy(t *testing.T) *dag.Graph {
   925  	g, err := dag.Parse(depsRules)
   926  	if err != nil {
   927  		t.Fatal(err)
   928  	}
   929  	return g
   930  }
   931  
   932  // TestStdlibLowercase tests that all standard library package names are
   933  // lowercase. See Issue 40065.
   934  func TestStdlibLowercase(t *testing.T) {
   935  	testenv.MustHaveSource(t)
   936  
   937  	ctxt := Default
   938  	all, err := listStdPkgs(ctxt.GOROOT)
   939  	if err != nil {
   940  		t.Fatal(err)
   941  	}
   942  
   943  	for _, pkgname := range all {
   944  		if strings.ToLower(pkgname) != pkgname {
   945  			t.Errorf("package %q should not use upper-case path", pkgname)
   946  		}
   947  	}
   948  }
   949  
   950  // TestFindImports tests that findImports works.  See #43249.
   951  func TestFindImports(t *testing.T) {
   952  	imports, err := findImports("go/build")
   953  	if err != nil {
   954  		t.Fatal(err)
   955  	}
   956  	t.Logf("go/build imports %q", imports)
   957  	want := []string{"bytes", "os", "path/filepath", "strings"}
   958  wantLoop:
   959  	for _, w := range want {
   960  		for _, imp := range imports {
   961  			if imp == w {
   962  				continue wantLoop
   963  			}
   964  		}
   965  		t.Errorf("expected to find %q in import list", w)
   966  	}
   967  }
   968  

View as plain text