aboutsummaryrefslogtreecommitdiff
path: root/src/go/types/api_test.go
AgeCommit message (Collapse)Author
2021-08-12[dev.typeparams] all: merge master (46fd547) into dev.typeparamsMatthew Dempsky
Conflicts: - src/go/types/check_test.go CL 324730 on dev.typeparams changed the directory paths in TestCheck, TestExamples, and TestFixedbugs and renamed checkFiles to testFiles; whereas CL 337529 on master added a new test case just above them and that used checkFiles. Merge List: + 2021-08-12 46fd547d89 internal/goversion: update Version to 1.18 + 2021-08-12 5805efc78e doc/go1.17: remove draft notice + 2021-08-12 39634e7dae CONTRIBUTORS: update for the Go 1.17 release + 2021-08-12 095bb790e1 os/exec: re-enable LookPathTest/16 + 2021-08-11 dea23e9ca8 src/make.*: make --no-clean flag a no-op that prints a warning + 2021-08-11 d4c0ed26ac doc/go1.17: linker passes -I to extld as -Wl,--dynamic-linker + 2021-08-10 1f9c9d8530 doc: use "high address/low address" instead of "top/bottom" + 2021-08-09 f1dce319ff cmd/go: with -mod=vendor, don't panic if there are duplicate requirements + 2021-08-09 7aeaad5c86 runtime/cgo: when using msan explicitly unpoison cgoCallers + 2021-08-08 507cc341ec doc: add example for conversion from slice expressions to array ptr + 2021-08-07 891547e2d4 doc/go1.17: fix a typo introduced in CL 335135 + 2021-08-06 8eaf4d16bc make.bash: do not overwrite GO_LDSO if already set + 2021-08-06 63b968f4f8 doc/go1.17: clarify Modules changes + 2021-08-06 70546f6404 runtime: allow arm64 SEH to be called if illegal instruction + 2021-08-05 fd45e267c2 runtime: warn that KeepAlive is not an unsafe.Pointer workaround + 2021-08-04 6e738868a7 net/http: speed up and deflake TestCancelRequestWhenSharingConnection + 2021-08-02 8a7ee4c51e io/fs: don't use absolute path in DirEntry.Name doc + 2021-07-31 b8ca6e59ed all: gofmt + 2021-07-30 b7a85e0003 net/http/httputil: close incoming ReverseProxy request body + 2021-07-29 70fd4e47d7 runtime: avoid possible preemption when returning from Go to C + 2021-07-28 9eee0ed439 cmd/go: fix go.mod file name printed in error messages for replacements + 2021-07-28 b39e0f461c runtime: don't crash on nil pointers in checkptrAlignment + 2021-07-27 7cd10c1149 cmd/go: use .mod instead of .zip to determine if version has go.mod file + 2021-07-27 c8cf0f74e4 cmd/go: add missing flag in UsageLine + 2021-07-27 7ba8e796c9 testing: clarify T.Name returns a distinct name of the running test + 2021-07-27 33ff155970 go/types: preserve untyped constants on the RHS of a shift expression + 2021-07-26 840e583ff3 runtime: correct variable name in comment + 2021-07-26 bfbb288574 runtime: remove adjustTimers counter + 2021-07-26 9c81fd53b3 cmd/vet: add missing copyright header Change-Id: Ia80604d24c6f4205265683024e3100769cf32065
2021-07-27go/types: preserve untyped constants on the RHS of a shift expressionRob Findley
CL 291316 fixed go/types to verify that untyped shift counts are representable by uint, but as a side effect also converted their types to uint. Rearrange the logic to keep the check for representability, but not actually convert untyped integer constants. Untyped non-integer constants are still converted, to preserve the behavior of 1.16. This behavior for non-integer types is a bug, filed as #47410. Updates #47410 Fixes #47243 Change-Id: I5eab4aab35b97f932fccdee2d4a18623ee2ccad5 Reviewed-on: https://go-review.googlesource.com/c/go/+/337529 Trust: Robert Findley <rfindley@google.com> Trust: Robert Griesemer <gri@golang.org> Run-TryBot: Robert Findley <rfindley@google.com> TryBot-Result: Go Bot <gobot@golang.org> Reviewed-by: Robert Griesemer <gri@golang.org>
2021-07-22[dev.typeparams] go/types: set type parameter indices when they are boundRob Findley
It is invalid to use a type parameter for more than one type, so we can avoid passing the type parameter index to NewTypeParam and just set it when type parameters are bound to a type via SetTParams or during type checking. In order to enforce the correctness of this change, introduce a TypeParams type to represent a list of type parameters that have been associated with a type. For now, expose this new type as the API for type parameters, but this is of course not necessarily a final API. Allowing *TypeParams to be nil also decreases the size of Named and Signature, which is good as most instances of these types will not be parameterized. Change-Id: Ia1e39ba51edb05bb535eb5f41c34e9dd02d39c38 Reviewed-on: https://go-review.googlesource.com/c/go/+/336249 Trust: Robert Findley <rfindley@google.com> Run-TryBot: Robert Findley <rfindley@google.com> TryBot-Result: Go Bot <gobot@golang.org> Reviewed-by: Robert Griesemer <gri@golang.org>
2021-07-19[dev.typeparams] go/types: replace types2.Instantiate with Checker.InstantiateRob Findley
This is a partial port of CL 333569 containing just changes to go/types. Changes to the importer wil be made in a separate CL. Change-Id: I9383e260b76402875ca6eb23c4478a6a3e8c1f0d Reviewed-on: https://go-review.googlesource.com/c/go/+/335071 Trust: Robert Findley <rfindley@google.com> Run-TryBot: Robert Findley <rfindley@google.com> Reviewed-by: Robert Griesemer <gri@golang.org> TryBot-Result: Go Bot <gobot@golang.org>
2021-07-19[dev.typeparams] go/types: add some missing APIs for the importerRob Findley
This is a partial port of CL 319930, containing only changes to go/types. Importer changes will be made in a separate CL. The TypeParams APIs are left unexported for now; they will be exported when they are needed. Change-Id: I74bd246d4c174cb38f8360d921c733fa03900eab Reviewed-on: https://go-review.googlesource.com/c/go/+/335143 Trust: Robert Findley <rfindley@google.com> Run-TryBot: Robert Findley <rfindley@google.com> TryBot-Result: Go Bot <gobot@golang.org> Reviewed-by: Robert Griesemer <gri@golang.org>
2021-07-19[dev.typeparams] go/types: recursive substitution must terminate (bug fix)Rob Findley
This is a port of CL 333383 to go/types. Change-Id: I7ff68116cbe63337dbcc834c473a2a5588274e36 Reviewed-on: https://go-review.googlesource.com/c/go/+/335115 Trust: Robert Findley <rfindley@google.com> Run-TryBot: Robert Findley <rfindley@google.com> TryBot-Result: Go Bot <gobot@golang.org> Reviewed-by: Robert Griesemer <gri@golang.org>
2021-07-16[dev.typeparams] go/internal/typeparams: remove the Enabled guardRob Findley
Type parameters are now always enabled. Users should guard against type checking generic code by using the types.Config.GoVersion field. This cleans up some differences with types2. Change-Id: Ie3e35a549e456a90a10d6a7e158ff58653cc1394 Reviewed-on: https://go-review.googlesource.com/c/go/+/335033 Trust: Robert Findley <rfindley@google.com> Run-TryBot: Robert Findley <rfindley@google.com> TryBot-Result: Go Bot <gobot@golang.org> Reviewed-by: Robert Griesemer <gri@golang.org>
2021-07-16[dev.typeparams] go/types: remove typeparams wrappers and aliasesRob Findley
These wrappers and aliases were necessary when we had different versions of the API depending on the typeparams build constraint, but now they're just boilerplate. Remove them. Notably the documentation for types.Info is restored. Change-Id: I5363d1d5df47649c2641c03328dfba45b1456278 Reviewed-on: https://go-review.googlesource.com/c/go/+/334895 Trust: Robert Findley <rfindley@google.com> Run-TryBot: Robert Findley <rfindley@google.com> TryBot-Result: Go Bot <gobot@golang.org> Reviewed-by: Robert Griesemer <gri@golang.org>
2021-06-17[dev.typeparams] go/types: disallow type list handlingRob Findley
This is a port of CL 324571 to go/types, though type list handling is guarded by a const rather than a config option. Change-Id: I91c940fead048980603e0bb56fcc896dbef4f94c Reviewed-on: https://go-review.googlesource.com/c/go/+/326683 Trust: Robert Findley <rfindley@google.com> Run-TryBot: Robert Findley <rfindley@google.com> TryBot-Result: Go Bot <gobot@golang.org> Reviewed-by: Robert Griesemer <gri@golang.org>
2021-06-04[dev.typeparams] go/types: use Checker-provided type parameter IDs when possibleRob Findley
Incrementing type parameter subscripts for each type checking pass is distracting for an interactive program where packages are type-checked on each keystroke. We should perhaps hide the type parameter ID altogether, but for now at least add a layer of indirection so that type parameters for a single type-checked package can be stabilized. This change should have no effect on non-generic type checking. For #46003 Change-Id: I60d747e0a2bfb68e7d64e897eac23f609a2a4429 Reviewed-on: https://go-review.googlesource.com/c/go/+/321269 Trust: Robert Findley <rfindley@google.com> Run-TryBot: Robert Findley <rfindley@google.com> TryBot-Result: Go Bot <gobot@golang.org> Reviewed-by: Robert Griesemer <gri@golang.org>
2021-04-28go/types: better errors for invalid short var declsRob Findley
This is a port of CL 312170 to go/types, adjusted to use go/ast and to add error codes. go/parser already emits errors for non-identifiers on the LHS of a short var decl, so a TODO is added to reconsider this redundancy. A new error code is added for repeated identifiers in short var decls. This is a bit specific, but I considered it to be a unique kind of error. The x/tools tests for this port turned up a bug: the new logic failed to call recordDef for blank identifiers. Patchset #2 contains the fix for this bug, both in go/types and cmd/compile/internal/types2. Change-Id: Ibdc40b8b4ad0e0696111d431682e1f1056fd5eeb Reviewed-on: https://go-review.googlesource.com/c/go/+/314629 Trust: Robert Findley <rfindley@google.com> Run-TryBot: Robert Findley <rfindley@google.com> TryBot-Result: Go Bot <gobot@golang.org> Reviewed-by: Robert Griesemer <gri@golang.org>
2021-04-28go/types: use a global atomic counter for type parameter idsRob Findley
This is a 1:1 port of CL 309830 to go/types. Change-Id: Ibf709f8194dd5e93a87145e5f9db674ce93af529 Reviewed-on: https://go-review.googlesource.com/c/go/+/314594 Trust: Robert Findley <rfindley@google.com> Run-TryBot: Robert Findley <rfindley@google.com> TryBot-Result: Go Bot <gobot@golang.org> Reviewed-by: Robert Griesemer <gri@golang.org>
2021-04-21go/types: allow conversion from slice to array ptrJosh Bleecher Snyder
These match the changes to cmd/compile/internal/types2 in CL 301650. Updates #395 Change-Id: I1e85b6355c8c8fdba0996c26a2505c65fab908d6 Reviewed-on: https://go-review.googlesource.com/c/go/+/301651 Trust: Josh Bleecher Snyder <josharian@gmail.com> Trust: Robert Griesemer <gri@golang.org> Run-TryBot: Josh Bleecher Snyder <josharian@gmail.com> TryBot-Result: Go Bot <gobot@golang.org> Reviewed-by: Robert Findley <rfindley@google.com> Reviewed-by: Robert Griesemer <gri@golang.org>
2021-04-20go/types: support type parameters in NewMethodSetRob Findley
Add handling for TypeParams in NewMethodSet, to bring it in sync with lookupFieldOrMethod. Also add a test, since we had none. I wanted this fix to get gopls completion working with type params, but due to the subtlety of lookupFieldOrMethod, I left a TODO to confirm that there are no behavioral differences between the APIs. Updates #45639 Change-Id: I16723e16d4d944ca4ecb4d87fc196815abb6fcff Reviewed-on: https://go-review.googlesource.com/c/go/+/311455 Trust: Robert Findley <rfindley@google.com> Trust: Robert Griesemer <gri@golang.org> Run-TryBot: Robert Findley <rfindley@google.com> TryBot-Result: Go Bot <gobot@golang.org> Reviewed-by: Robert Griesemer <gri@golang.org>
2021-04-13go/*,cmd/gofmt: guard AST changes with the typeparams build tagRob Findley
This CL changes our approach to guarding type parameter functionality and API. Previously, we guarded type parameter functionality with the parser.parseTypeParams parser mode, and were in the process of hiding the type parameter API behind the go1.18 build constraint. These mechanisms had several limitations: + Requiring the parser.parseTypeParams mode to be set meant that existing tooling would have to opt-in to type parameters in all places where it parses Go files. + The parseTypeParams mode value had to be copied in several places. + go1.18 is not specific to typeparams, making it difficult to set up the builders to run typeparams tests. This CL addresses the above limitations, and completes the task of hiding the AST API, by switching to a new 'typeparams' build constraint and adding a new go/internal/typeparams helper package. The typeparams build constraint is used to conditionally compile the new AST changes. The typeparams package provides utilities for accessing and writing the new AST data, so that we don't have to fragment our parser or type checker logic across build constraints. The typeparams.Enabled const is used to guard tests that require type parameter support. The parseTypeParams parser mode is gone, replaced by a new typeparams.DisableParsing mode with the opposite sense. Now, type parameters are only parsed if go/parser is compiled with the typeparams build constraint set AND typeparams.DisableParsing not set. This new parser mode allows opting out of type parameter parsing for tests. How exactly to run tests on builders is left to a follow-up CL. Updates #44933 Change-Id: I3091e42a2e5e2f23e8b2ae584f415a784b9fbd65 Reviewed-on: https://go-review.googlesource.com/c/go/+/300649 Trust: Robert Findley <rfindley@google.com> Run-TryBot: Robert Findley <rfindley@google.com> TryBot-Result: Go Bot <gobot@golang.org> Reviewed-by: Robert Griesemer <gri@golang.org>
2021-03-18go/types: add test case for issue #45096Robert Griesemer
This verifies that issue #45096 is not an issue for go/types. Updates #45096. Change-Id: I4e987b5d4928f0c864d0d2c0379149443beb4d5c Reviewed-on: https://go-review.googlesource.com/c/go/+/302754 Trust: Robert Griesemer <gri@golang.org> Run-TryBot: Robert Griesemer <gri@golang.org> Reviewed-by: Robert Findley <rfindley@google.com>
2021-03-02go/parser,go/types: hide API changes related to type parametersRob Findley
While the dev.typeparams branch was merged, the type parameter API is slated for go1.18. Hide these changes to the go/parser and go/types API. This was done as follows: + For APIs that will probably not be needed for go1.18, simply unexport them. + For APIs that we expect to export in go1.18, prefix symbols with '_', so that the planned (upper-cased) symbol name is apparent. + For APIs that must be exported for testing, move both API and tests to files guarded by the go1.18 build constraint. + parser.ParseTypeParams is unexported and copied wherever it is needed. + The -G flag is removed from gofmt, replaced by enabling type parameters if built with the go1.18 build constraint. Notably, changes related to type parameters in go/ast are currently left exported. We're looking at the AST API separately. The new API diff from 1.16 is: +pkg go/ast, method (*FuncDecl) IsMethod() bool +pkg go/ast, method (*ListExpr) End() token.Pos +pkg go/ast, method (*ListExpr) Pos() token.Pos +pkg go/ast, type FuncType struct, TParams *FieldList +pkg go/ast, type ListExpr struct +pkg go/ast, type ListExpr struct, ElemList []Expr +pkg go/ast, type TypeSpec struct, TParams *FieldList +pkg go/types, type Config struct, GoVersion string Change-Id: I1baf67e26279b49092e774309a836c460979774a Reviewed-on: https://go-review.googlesource.com/c/go/+/295929 Trust: Robert Findley <rfindley@google.com> Trust: Robert Griesemer <gri@golang.org> Run-TryBot: Robert Findley <rfindley@google.com> TryBot-Result: Go Bot <gobot@golang.org> Reviewed-by: Robert Griesemer <gri@golang.org>
2021-02-18[dev.typeparams] go/types: use a new ast.ListExpr for multi-type instancesRob Findley
Modify go/parser to consistently represent type instantiation as an ast.IndexExpr, rather than use an ast.CallExpr (with Brackets:true) for instantiations with multiple type parameters. To enable this, introduce a new ast expr type: ListExpr. This brings go/types in line with types2, with the exception of a small change to funcInst to eliminate redundant errors if values are erroneously used as types. In a subsequent CL, call.go and expr.go will be marked as reviewed. This also catches some type instance syntax using '()' that was previously accepted incorrectly. Tests are updated accordingly. Change-Id: I30cd0181c7608f1be7486a9a8b63df993b412e85 Reviewed-on: https://go-review.googlesource.com/c/go/+/293010 Trust: Robert Findley <rfindley@google.com> Trust: Robert Griesemer <gri@golang.org> Run-TryBot: Robert Findley <rfindley@google.com> TryBot-Result: Go Bot <gobot@golang.org> Reviewed-by: Robert Griesemer <gri@golang.org>
2021-02-12[dev.typeparams] go/types: make predeclared "any" alias for interface{}Rob Findley
This is a direct port of CL 285132 to go/types. Change-Id: I35486d8ea1fa6c0c6a32ece199a6ccfd55d44d29 Reviewed-on: https://go-review.googlesource.com/c/go/+/291322 Trust: Robert Findley <rfindley@google.com> Run-TryBot: Robert Findley <rfindley@google.com> TryBot-Result: Go Bot <gobot@golang.org> Reviewed-by: Robert Griesemer <gri@golang.org>
2021-02-08[dev.typeparams] merge dev.regabi (618e3c1) into dev.typeparamsRob Findley
This involved a couple non-trivial fixes in go/types: - move the check for main function signature to resolver.go, to be consistent with init. Also, update uses of _InvalidInitSig to _InvalidInitDecl, consistent with what we decided for dev.regabi. - Update some tests in api_test.go which newly fail after CL 289715 (fixing reporting of untyped nil) In all cases but one, these updates were consistent with types2. However, in one case types2 seems to be able to resolve more type information than go/types for a broken package. I left a TODO to investigate this further. Change-Id: I8244b7c81654194edd5af8de689a13c262117dff
2021-02-08[dev.regabi] go/types: consistently report nil type as "untyped nil"Rob Findley
This is a port of CL 284052 to go/types. The port is not entirely faithful, as untyped conversion has been refactored in go/types. Additionally, a comment was added to reference issue #13061 in the implicitType method. For #13061 Change-Id: Iec17611f6432c988624023d1d74121ff34eb0c83 Reviewed-on: https://go-review.googlesource.com/c/go/+/289715 Run-TryBot: Robert Findley <rfindley@google.com> TryBot-Result: Go Bot <gobot@golang.org> Trust: Robert Findley <rfindley@google.com> Trust: Robert Griesemer <gri@golang.org> Reviewed-by: Robert Griesemer <gri@golang.org>
2021-01-22[dev.typeparams] go/types: import api_test.go changes from dev.go2goRob Findley
This CL imports tests for the go/types API from the dev.go2go branch. Only parse type parameters for packages with a magic prefix, with the rationale that while generics are in preview, we want existing (non-generic) tests to exercise the default mode. Change-Id: I8ae0d8769b997a8a93b708453a1afaecb262244d Reviewed-on: https://go-review.googlesource.com/c/go/+/284693 Run-TryBot: Robert Findley <rfindley@google.com> TryBot-Result: Go Bot <gobot@golang.org> Trust: Robert Findley <rfindley@google.com> Trust: Robert Griesemer <gri@golang.org> Reviewed-by: Robert Griesemer <gri@golang.org>
2020-08-28go/types: factor out usage of implicit typeRob Findley
There was some duplication of logic interpreting the implicit type of an operand in assignableTo and convertUntyped. Factor out this logic to a new 'implicitType' function, which returns the implicit type of an untyped operand when used in a context where a target type is expected. I believe this resolves some comments about code duplication. There is other similar code in assignable, assignableTo, and convertUntypes, but I found it to to be sufficiently semantically distinct to not warrant factoring out. Change-Id: I199298a2e58fcf05344318fca0226b460c57867d Reviewed-on: https://go-review.googlesource.com/c/go/+/242084 Run-TryBot: Robert Findley <rfindley@google.com> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Robert Griesemer <gri@golang.org>
2020-08-27go/types: add untyped test cases for AssignableTo APIRob Findley
The AssignableTo API is specifically for non-constant values, but is currently called by gopls for constant completions. Add a test to ensure that we handle this edge case correctly. Change-Id: I83115cbca2443a783df1c3090b5741260dffb78e Reviewed-on: https://go-review.googlesource.com/c/go/+/250258 Run-TryBot: Robert Findley <rfindley@google.com> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Robert Griesemer <gri@golang.org>
2020-08-24go/types: add tests for AssignableTo and ConvertibleToRob Findley
These exported functions are mostly trivial wrappers, but do make certain assumptions about how the underlying Checker APIs can be called. Add some simple tests. Change-Id: I68e9ae875353c12d118ec961a6f3834385fbbb97 Reviewed-on: https://go-review.googlesource.com/c/go/+/241262 Run-TryBot: Robert Findley <rfindley@google.com> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Robert Griesemer <gri@golang.org>
2018-10-22go/types: report error for invalid use of ... in parameter listsRobert Griesemer
The parser accepts ...T types in parameter lists whereever a type is permitted; this matches the syntax and allows for more tolerant parsing and error recovery. go/types on the other hand assumed that the parser would report those errors and assumed any outstanding such errors would be due to otherwise manipulated ASTs leading to invalid ASTs. go/types further assumed that a parameter list (a, b, c ...int) was permitted (a couple of tests used such parameter lists). With this CL, go/types now correctly refuses invalid parameter lists. Fixes #28281. Change-Id: Ib788255f7b7819fdb972c7801bb153a53ce2ddf7 Reviewed-on: https://go-review.googlesource.com/c/143857 Run-TryBot: Robert Griesemer <gri@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Alan Donovan <adonovan@google.com>
2018-10-19go/types: collect type info for type ...T in variadic functionsRobert Griesemer
Because the code type-checks T rather than ...T (and then corrects the type to []T "manually"), it didn't automatically record the type for the ast.Expr corresponding to ...T. Do it manually. Fixes #28277. Change-Id: I3d9aae310c90b01f52d189e70c48dd9007f72207 Reviewed-on: https://go-review.googlesource.com/c/143317 Reviewed-by: Alan Donovan <adonovan@google.com>
2018-08-30go/types: fix crash following misuse of [...]T in composite literalRebecca Stambler
The type-checker currently crashes when checking code such as: _ = map[string][...]int{"": {1, 2, 3}} In this case, the type checker reports an error for map[string][...]int, then proceeds to type-check the values of the map literal using a hint type of [...]int. When type-checking the inner composite (array) literal, the length of the open array type is computed from the elements, then the array type is recorded, but the literal has no explicit type syntax against which to record the type, so this code causes the type-checker to panic. Add a nil check before calling check.recordTypeAndValue to avoid that. Updates #22467 Change-Id: Ic4453ba485b7b88ede2a89f209365eda9e032abc Reviewed-on: https://go-review.googlesource.com/132355 Reviewed-by: Alan Donovan <adonovan@google.com>
2018-08-30go/types: handle nil pointer when panic is written outside of a functionRebecca Stambler
The current implementation crashes when someone writes a panic outside of a function, which makes sense since that is broken code. This fix allows one to type-check broken code. Updates #22467 Change-Id: I81b90dbd918162a20c60a821340898eaf02e648d Reviewed-on: https://go-review.googlesource.com/132235 Reviewed-by: Alan Donovan <adonovan@google.com>
2018-08-09go/types: fix errors in recording type informationRebecca Stambler
In my previous change, I didn't use the correct functions for continuing to record type informations after errors. Change to using the correct functions, and add a comment to clarify in expr.go. Updates #22467 Change-Id: I66ebb636ceb2b994db652343430f0551db0050c3 Reviewed-on: https://go-review.googlesource.com/128835 Run-TryBot: Robert Griesemer <gri@golang.org> Reviewed-by: Robert Griesemer <gri@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org>
2018-07-12go/types: record type information after detecting errorRebecca Stambler
The existing implementation stops recording type information once it encounters an error. This results in missing type information that is needed by various tools. This change handles a few commonly encountered cases by continuing to check subtrees after errors. Also, add tests for cases where the package fails to type-check. Updates #22467 Change-Id: I1bb48d4cb8ae5548dca63bdd785ea2f69329e92b Reviewed-on: https://go-review.googlesource.com/123578 Run-TryBot: Rebecca Stambler <rstambler@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Alan Donovan <adonovan@google.com>
2017-12-01go/types: don't use directory foo which might exist under GOPATHRobert Griesemer
Simply choose an extremely unlikely path name in the test is fine. Fixes #21013. Change-Id: I56c0a1986b5ef5d618c7fe2b14701f584fe81c37 Reviewed-on: https://go-review.googlesource.com/81578 Run-TryBot: Robert Griesemer <gri@golang.org> Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org>
2017-10-19go/types: add test verifying corner-case behavior of iotagriesemer
For #22341. Change-Id: I7e586c58075e4c835ef97701db2f38bdf7558521 Reviewed-on: https://go-review.googlesource.com/71974 Run-TryBot: Robert Griesemer <gri@golang.org> Reviewed-by: Matthew Dempsky <mdempsky@google.com> TryBot-Result: Gobot Gobot <gobot@golang.org>
2017-09-25go/types: don't accept incorrect shift expression argumentsgriesemer
Under certain circumstances involving shifts, go/types didn't verify that untyped constant values were representable by the relevant type, leading to the acceptance of incorrect programs (see the issue). Fixing this code exposed another problem with int-to-string conversions which suddenly failed because now the type-checker complained that a (constant) integer argument wasn't representable as a string. Fixed that as well. Added many additional tests covering the various scenarious. Found two cmd/compile bugs in the process (#21979, #21981) and filed a go/types TODO (#21982). Fixes #21727. Change-Id: If443ee0230979cd7d45d2fc669e623648caa70da Reviewed-on: https://go-review.googlesource.com/65370 Reviewed-by: Alan Donovan <adonovan@google.com>
2017-09-01go/types: fix Info.Implicits entriesgriesemer
Packages of dot imports don't appear in the Info.Implicits map since they are already taken care of by the Info.Defs map. Fix documentation. Implicitly dot-imported objects of a package shouldn't appear in the Info.Implicits map because the documentation never said so and there's no way to map multiple objects to the same *ast.ImportSpec with the current data structure. Added missing test for Info.Implicits. The fix is a trivial one-line deletion, the rest is documentation and test. Fixes #21591. Change-Id: I12a37dab85c531911c9363ec3d58daa095c7eb24 Reviewed-on: https://go-review.googlesource.com/60672 Reviewed-by: Alan Donovan <adonovan@google.com>
2017-03-06go/types: continue type-checking with fake packages if imports failedRobert Griesemer
This will make type-checking more robust in the presence of import errors. Also: - import is now relative to directory containing teh file containing the import (matters for relative imports) - factored out package import code from main resolver loop - fixed a couple of minor bugs Fixes #16088. Change-Id: I1ace45c13cd0fa675d1762877cec0a30afd9ecdc Reviewed-on: https://go-review.googlesource.com/37697 Run-TryBot: Robert Griesemer <gri@golang.org> Reviewed-by: Alan Donovan <adonovan@google.com> TryBot-Result: Gobot Gobot <gobot@golang.org>
2017-01-10[dev.typealias] go/types: remove some more vestiges of prior alias ↵Robert Griesemer
implementation For #18130. Change-Id: Ibec8efd158d32746978242910dc71e5ed23e9d91 Reviewed-on: https://go-review.googlesource.com/35092 Run-TryBot: Robert Griesemer <gri@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Alan Donovan <adonovan@google.com>
2016-11-04go/types: revert user-visible changes related to aliasesRobert Griesemer
Reason: Decision to back out current alias implementation. For #16339 (comment). Change-Id: Ie04f24e529db2d29c5dd2e36413f5f37f628df39 Reviewed-on: https://go-review.googlesource.com/32819 Reviewed-by: Matthew Dempsky <mdempsky@google.com>
2016-11-01go/importer: handle multiple imports of the same objectRobert Griesemer
Before aliases, and because we chose a simple export format for them, a package may now export the same object more than once if there are multiple exported aliases referring to that object. The go/importer made the assumption this couldn't happen. Adjust it. Fixes #17726. Change-Id: Ibb9fc669a8748200b45ad78934d7453e5a5aad82 Reviewed-on: https://go-review.googlesource.com/32538 Reviewed-by: Matthew Dempsky <mdempsky@google.com> Run-TryBot: Robert Griesemer <gri@golang.org>
2016-11-01go/types: handle imported aliasesRobert Griesemer
When we lookup a qualified identifier, we need to unpack an alias. Do this in all places, not just one. Duh! Fixes #17716. For #17592. Change-Id: I58d57b17cc635d0408b370f109c719c16757fd8e Reviewed-on: https://go-review.googlesource.com/32534 Reviewed-by: Alan Donovan <adonovan@google.com>
2016-10-31go/types: basic Defs/Uses test for aliasesRobert Griesemer
Change-Id: I113ea712838511ee823375d9ea059089195414f5 Reviewed-on: https://go-review.googlesource.com/32449 Run-TryBot: Robert Griesemer <gri@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Alan Donovan <adonovan@google.com>
2016-08-18go/types: better doc string for Object.Parent and testRobert Griesemer
Fixes #14647. Change-Id: Ib9012a9141e815f5b95f8ca2307e65ffc4587a5b Reviewed-on: https://go-review.googlesource.com/27370 Reviewed-by: Matthew Dempsky <mdempsky@google.com>
2016-08-18go/types: fix scope extents for range and type switch variablesRobert Griesemer
The changes match the existing compilers, and assume an adjusted spec (per issue #16794). Fixes #15686. Change-Id: I72677ce75888c41a8f3c2963117a2f2d5501c42b Reviewed-on: https://go-review.googlesource.com/27290 Reviewed-by: Matthew Dempsky <mdempsky@google.com>
2016-08-18go/types: set Info.Types.Type for array composite literals of the form [...]TRobert Griesemer
Fixes #14092. Change-Id: I00692f60a416348e38cab256b94fda07e334d258 Reviewed-on: https://go-review.googlesource.com/27316 Reviewed-by: Matthew Dempsky <mdempsky@google.com>
2016-08-17go/types: enable disabled test for comma-ok expressionsRobert Griesemer
This was fixed long ago but the test was not enabled. For #8189. Change-Id: Ia44ef752b6bf076f3e243d2d0db326a392a20193 Reviewed-on: https://go-review.googlesource.com/27310 Run-TryBot: Robert Griesemer <gri@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org>
2016-08-16go/types: fix computation of initialization orderRobert Griesemer
The old algorithm operated on a dependency graph that included all objects (including functions) for simplicity: it was based directly on the dependencies collected for each object during type checking an object's initialization expression. It also used that graph to compute the objects involved in an erroneous initialization cycle. Cycles that consist only of (mutually recursive) functions are permitted in initialization code; so those cycles were silently ignored if encountered. However, such cycles still inflated the number of dependencies a variable might have (due to the cycle), which in some cases lead to the wrong variable being scheduled for initialization before the one with the inflated dependency count. Correcting for the cycle when it is found is too late since at that point another variable may have already been scheduled. The new algorithm computes the initialization dependency graph as before but adds an extra pass during which functions are eliminated from the graph (and their dependencies are "back-propagated"). This eliminates the problem of cycles only involving functions (there are no functions). When a cycle is found, the new code computes the cycle path from the original object dependencies so it can still include functions on the path as before, for the same detailed error message. The new code also more clearly distinguishes between objects that can be in the dependency graph (constants, variables, functions), and objects that cannot, by introducing the dependency type, a new subtype of Object. As a consequence, the dependency graph is smaller. Fixes #10709. Change-Id: Ib58d6ea65cfb279041a0286a2c8e865f11d244eb Reviewed-on: https://go-review.googlesource.com/24131 Reviewed-by: Alan Donovan <adonovan@google.com>
2016-05-27go/types: better debugging output for init order computationRobert Griesemer
Also: Added some test cases for issue #10709. No impact when debugging output is disabled (default). For #10709. Change-Id: I0751befb222c86d46225377a674f6bad2990349e Reviewed-on: https://go-review.googlesource.com/23442 Reviewed-by: Alan Donovan <adonovan@google.com>
2016-04-14go/types: record CallExpr result type even if argument is invalidAlan Donovan
+ test Fixes #15305 Change-Id: Ica657c00c92f0b19f0df7452cdbe5a95d23cc8a4 Reviewed-on: https://go-review.googlesource.com/22085 Reviewed-by: Robert Griesemer <gri@golang.org>
2016-04-07go/types: make Identical(nil, T) == Identical(T, nil)Alan Donovan
Fixes #15173 Change-Id: I353756f7bc36db0d2b24d40c80771481b7b18f6b Reviewed-on: https://go-review.googlesource.com/21585 Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org> Run-TryBot: Brad Fitzpatrick <bradfitz@golang.org>
2015-12-14go/constant: switch to floating-point representation when fractions become ↵Robert Griesemer
too large Use two internal representations for Float values (similar to what is done for Int values). Transparently switch to a big.Float representation when big.Rat values become unwieldy. This is almost never needed for real-world programs but it is trivial to create test cases that cannot be handled with rational arithmetic alone. As a consequence, the go/constant API semantics changes slightly: Until now, a value could always be represented in its "smallest" form (e.g., float values that happened to be integers would be represented as integers). Now, constant Kind depends on how the value was created, rather than its actual value. (The reason why we cannot automatically "normalize" values to their smallest form anymore is because floating-point numbers are not exact in general; and thus normalization is often not possible in the first place, or would throw away precision when it is not desired.) This has repercussions as to how constant Values are used go/types and required corresponding adjustments. Details of the changes: go/constant package: - use big.Rat and big.Float values to represent floating-point values (internal change) - changed semantic of Value.Kind accordingly - String now returns a short, human-readable form of a value (this leads to better error messages in go/types) - added ToInt, ToFloat, and ToComplex conversion functions - added ExactString to obtain an exact string form of a value go/types: - adjusted and simplified implementation of representableConst - adjusted various places where Value.Kind was expected to be "smallest" by calling the respective ToInt/Float/Complex conversion functions - enabled 5 disabled tests in stdlib_test.go that now work api checker: - print all constant values in a short human-readable form (floats are printed in floating-point form), but also print an exact form if it is different from the short form - adjusted test golden file and go.1.1.text reference file Fixes #11327. Change-Id: I492b704aae5b0238e5b7cee13e18ffce61193587 Reviewed-on: https://go-review.googlesource.com/17360 Reviewed-by: Alan Donovan <adonovan@google.com> Run-TryBot: Robert Griesemer <gri@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org>
7apu2bq3rhoylwmucxizk54afw5jyda7pho4j5zdcqpwkufke7zdzwad.onion