go/internal/gccgoimporter: ignore unexported and imported names

    Due to inlining, we can now see unexported functions and variables,
    and functions and variables imported from different packages.
    Ignore them rather than reporting them from this package.

    Handle $hash and $equal functions consistently, so that we discard the
    inline body if there is one.

    Ignore names created for result parameters for inlining purposes.

    Reviewed-on: https://go-review.googlesource.com/c/gofrontend/+/180758

From-SVN: r272023

diff --git a/gcc/go/gofrontend/MERGE b/gcc/go/gofrontend/MERGE
index 4d455ea802360bfa08771a8274909db9c3dc6c6c..7f687c8cc00c9cafa45be5b845289656f90cb59b 100644 (file)
--- a/gcc/go/gofrontend/MERGE
+++ b/gcc/go/gofrontend/MERGE
@@ -1,4 +1,4 @@
-015785baa74629baafe520367b9c71707366c6eb
+e76c26059585433ce44e50cd7f8f504c6676f453
 
 The first line of this file holds the git revision number of the last
 merge done from the gofrontend repository.

diff --git a/libgo/go/go/internal/gccgoimporter/parser.go b/libgo/go/go/internal/gccgoimporter/parser.go
index 956a9a85c10b13c5224a5a94b43938da351b149f..5881d9c79cb7363373c6854a0507d053aeee7bec 100644 (file)
--- a/libgo/go/go/internal/gccgoimporter/parser.go
+++ b/libgo/go/go/internal/gccgoimporter/parser.go
@@ -261,6 +261,10 @@ func (p *parser) parseField(pkg *types.Package) (field *types.Var, tag string) {
 // Param = Name ["..."] Type .
 func (p *parser) parseParam(pkg *types.Package) (param *types.Var, isVariadic bool) {
        name := p.parseName()
+       // Ignore names invented for inlinable functions.
+       if strings.HasPrefix(name, "p.") || strings.HasPrefix(name, "r.") || strings.HasPrefix(name, "$ret") {
+               name = ""
+       }
        if p.tok == '<' && p.scanner.Peek() == 'e' {
                // EscInfo = "<esc:" int ">" . (optional and ignored)
                p.next()
@@ -286,7 +290,14 @@ func (p *parser) parseParam(pkg *types.Package) (param *types.Var, isVariadic bo
 // Var = Name Type .
 func (p *parser) parseVar(pkg *types.Package) *types.Var {
        name := p.parseName()
-       return types.NewVar(token.NoPos, pkg, name, p.parseType(pkg))
+       v := types.NewVar(token.NoPos, pkg, name, p.parseType(pkg))
+       if name[0] == '.' || name[0] == '<' {
+               // This is an unexported variable,
+               // or a variable defined in a different package.
+               // We only want to record exported variables.
+               return nil
+       }
+       return v
 }
 
 // Conversion = "convert" "(" Type "," ConstValue ")" .
@@ -741,14 +752,17 @@ func (p *parser) parseFunc(pkg *types.Package) *types.Func {
        }
 
        name := p.parseName()
-       if strings.ContainsRune(name, '$') {
-               // This is a Type$equal or Type$hash function, which we don't want to parse,
-               // except for the types.
-               p.discardDirectiveWhileParsingTypes(pkg)
-               return nil
-       }
        f := types.NewFunc(token.NoPos, pkg, name, p.parseFunctionType(pkg, nil))
        p.skipInlineBody()
+
+       if name[0] == '.' || name[0] == '<' || strings.ContainsRune(name, '$') {
+               // This is an unexported function,
+               // or a function defined in a different package,
+               // or a type$equal or type$hash function.
+               // We only want to record exported functions.
+               return nil
+       }
+
        return f
 }
 
@@ -769,7 +783,9 @@ func (p *parser) parseInterfaceType(pkg *types.Package, nlist []int) types.Type
                        embeddeds = append(embeddeds, p.parseType(pkg))
                } else {
                        method := p.parseFunc(pkg)
-                       methods = append(methods, method)
+                       if method != nil {
+                               methods = append(methods, method)
+                       }
                }
                p.expect(';')
        }
@@ -1050,23 +1066,6 @@ func (p *parser) parsePackageInit() PackageInit {
        return PackageInit{Name: name, InitFunc: initfunc, Priority: priority}
 }
 
-// Throw away tokens until we see a newline or ';'.
-// If we see a '<', attempt to parse as a type.
-func (p *parser) discardDirectiveWhileParsingTypes(pkg *types.Package) {
-       for {
-               switch p.tok {
-               case '\n', ';':
-                       return
-               case '<':
-                       p.parseType(pkg)
-               case scanner.EOF:
-                       p.error("unexpected EOF")
-               default:
-                       p.next()
-               }
-       }
-}
-
 // Create the package if we have parsed both the package path and package name.
 func (p *parser) maybeCreatePackage() {
        if p.pkgname != "" && p.pkgpath != "" {
@@ -1204,7 +1203,9 @@ func (p *parser) parseDirective() {
        case "var":
                p.next()
                v := p.parseVar(p.pkg)
-               p.pkg.Scope().Insert(v)
+               if v != nil {
+                       p.pkg.Scope().Insert(v)
+               }
                p.expectEOL()
 
        case "const":