qbit/go
1
0
Fork 0
mirror of https://github.com/golang/go synced 2024-11-05 16:56:16 -07:00
Code Releases Activity
a9866431ad
go/refactor/lexical/lexical_test.go

50 lines
1.2 KiB
Go
Raw Normal View History

refactor/lexical: understand the structure of the lexical environment. The Uses, Defs and Scope information provided by go/types is inadequate for answering "what if?" queries about the structure of the lexical environment. In this code, for example, var x int func f() { print(x) x := "" print(x) } the two referring Idents x appear at the same lexical depth, inside the function f's Scope object, yet they resolve to different objects. This package associates a lexical.Environment instance with every reference to capture these differences. Each environment is a linked list of enclosing Blocks, and for each block, a number indicating what prefix of its bindings are visible. (Zero for the first 'x' reference above, 1 for the second.) + Smoke test over stdlib. This functionality could be integrated with the type checker in lieu of the not-so-useful types.Info.Scopes data, at little extra cost in code or in running time/space. We should talk about that. LGTM=sameer R=gri, sameer CC=golang-codereviews https://golang.org/cl/143790043
2014-09-19 11:11:01 -06:00
// Copyright 2014 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
package lexical
import (
"go/build"
"testing"
go.tools: use golang.org/x/... import paths Rewrite performed with this command: sed -i '' 's_code.google.com/p/go\._golang.org/x/_g' \ $(grep -lr 'code.google.com/p/go.' *) LGTM=rsc R=rsc CC=golang-codereviews https://golang.org/cl/170920043
2014-11-09 14:50:40 -07:00
"golang.org/x/tools/go/buildutil"
"golang.org/x/tools/go/loader"
refactor/lexical: understand the structure of the lexical environment. The Uses, Defs and Scope information provided by go/types is inadequate for answering "what if?" queries about the structure of the lexical environment. In this code, for example, var x int func f() { print(x) x := "" print(x) } the two referring Idents x appear at the same lexical depth, inside the function f's Scope object, yet they resolve to different objects. This package associates a lexical.Environment instance with every reference to capture these differences. Each environment is a linked list of enclosing Blocks, and for each block, a number indicating what prefix of its bindings are visible. (Zero for the first 'x' reference above, 1 for the second.) + Smoke test over stdlib. This functionality could be integrated with the type checker in lieu of the not-so-useful types.Info.Scopes data, at little extra cost in code or in running time/space. We should talk about that. LGTM=sameer R=gri, sameer CC=golang-codereviews https://golang.org/cl/143790043
2014-09-19 11:11:01 -06:00
)
func TestStdlib(t *testing.T) {
defer func(saved func(format string, args ...interface{})) {
logf = saved
}(logf)
logf = t.Errorf
ctxt := build.Default // copy
// Enumerate $GOROOT packages.
saved := ctxt.GOPATH
ctxt.GOPATH = "" // disable GOPATH during AllPackages
pkgs := buildutil.AllPackages(&ctxt)
ctxt.GOPATH = saved
// Throw in a number of go.tools packages too.
pkgs = append(pkgs,
go.tools: use golang.org/x/... import paths Rewrite performed with this command: sed -i '' 's_code.google.com/p/go\._golang.org/x/_g' \ $(grep -lr 'code.google.com/p/go.' *) LGTM=rsc R=rsc CC=golang-codereviews https://golang.org/cl/170920043
2014-11-09 14:50:40 -07:00
"golang.org/x/tools/cmd/godoc",
"golang.org/x/tools/refactor/lexical")
refactor/lexical: understand the structure of the lexical environment. The Uses, Defs and Scope information provided by go/types is inadequate for answering "what if?" queries about the structure of the lexical environment. In this code, for example, var x int func f() { print(x) x := "" print(x) } the two referring Idents x appear at the same lexical depth, inside the function f's Scope object, yet they resolve to different objects. This package associates a lexical.Environment instance with every reference to capture these differences. Each environment is a linked list of enclosing Blocks, and for each block, a number indicating what prefix of its bindings are visible. (Zero for the first 'x' reference above, 1 for the second.) + Smoke test over stdlib. This functionality could be integrated with the type checker in lieu of the not-so-useful types.Info.Scopes data, at little extra cost in code or in running time/space. We should talk about that. LGTM=sameer R=gri, sameer CC=golang-codereviews https://golang.org/cl/143790043
2014-09-19 11:11:01 -06:00
// Load, parse and type-check the program.
go/loader: rename SourceImports flag to ImportFromBinary and invert sense ...since the zero value is more useful by far. This is a breaking API change, obviously. (One or two tests in this CL have intentional been left using the zero value, i.e., they now load source.) Change-Id: I42287bfcdb1afef8ee84e5eac12534dd0a1fd5d2 Reviewed-on: https://go-review.googlesource.com/5653 Reviewed-by: Robert Griesemer <gri@golang.org>
2015-02-23 15:03:22 -07:00
conf := loader.Config{Build: &ctxt}
refactor/lexical: understand the structure of the lexical environment. The Uses, Defs and Scope information provided by go/types is inadequate for answering "what if?" queries about the structure of the lexical environment. In this code, for example, var x int func f() { print(x) x := "" print(x) } the two referring Idents x appear at the same lexical depth, inside the function f's Scope object, yet they resolve to different objects. This package associates a lexical.Environment instance with every reference to capture these differences. Each environment is a linked list of enclosing Blocks, and for each block, a number indicating what prefix of its bindings are visible. (Zero for the first 'x' reference above, 1 for the second.) + Smoke test over stdlib. This functionality could be integrated with the type checker in lieu of the not-so-useful types.Info.Scopes data, at little extra cost in code or in running time/space. We should talk about that. LGTM=sameer R=gri, sameer CC=golang-codereviews https://golang.org/cl/143790043
2014-09-19 11:11:01 -06:00
for _, path := range pkgs {
go/loader: improve robustness in face of input errors Before this change, many kinds of error would cause the loader to stop. making it brittle when analyzing large codebases, as in "godoc -analysis". This change moves operations that used to occur during configuration---(*build.Context).Import, loading, and parsing of initial packages---into the Load call, and ensures that all failures during Loading are reported at the end so that the maximum amount of progress is made. Also: redesign the tests and add many new cases. Change-Id: Ia8cd99416af7c5d4a5fe133908adfa83676d401f Reviewed-on: https://go-review.googlesource.com/3626 Reviewed-by: Robert Griesemer <gri@golang.org>
2015-01-30 11:30:23 -07:00
conf.ImportWithTests(path)
refactor/lexical: understand the structure of the lexical environment. The Uses, Defs and Scope information provided by go/types is inadequate for answering "what if?" queries about the structure of the lexical environment. In this code, for example, var x int func f() { print(x) x := "" print(x) } the two referring Idents x appear at the same lexical depth, inside the function f's Scope object, yet they resolve to different objects. This package associates a lexical.Environment instance with every reference to capture these differences. Each environment is a linked list of enclosing Blocks, and for each block, a number indicating what prefix of its bindings are visible. (Zero for the first 'x' reference above, 1 for the second.) + Smoke test over stdlib. This functionality could be integrated with the type checker in lieu of the not-so-useful types.Info.Scopes data, at little extra cost in code or in running time/space. We should talk about that. LGTM=sameer R=gri, sameer CC=golang-codereviews https://golang.org/cl/143790043
2014-09-19 11:11:01 -06:00
}
iprog, err := conf.Load()
if err != nil {
t.Fatalf("Load failed: %v", err)
}
// This test ensures that Structure doesn't panic and that
// its internal sanity-checks against go/types don't fail.
for pkg, info := range iprog.AllPackages {
_ = Structure(iprog.Fset, pkg, &info.Info, info.Files)
}
}
Copy Permalink