go/internal/gccgoimporter: ignore unexported and imported names
authorIan Lance Taylor <ian@gcc.gnu.org>
Fri, 7 Jun 2019 00:07:50 +0000 (00:07 +0000)
committerIan Lance Taylor <ian@gcc.gnu.org>
Fri, 7 Jun 2019 00:07:50 +0000 (00:07 +0000)
    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

gcc/go/gofrontend/MERGE
libgo/go/go/internal/gccgoimporter/parser.go

index 4d455ea802360bfa08771a8274909db9c3dc6c6c..7f687c8cc00c9cafa45be5b845289656f90cb59b 100644 (file)
@@ -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.
index 956a9a85c10b13c5224a5a94b43938da351b149f..5881d9c79cb7363373c6854a0507d053aeee7bec 100644 (file)
@@ -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":