[llgo] irgen, driver: modify Compiler.Compile to take a FileSet and Files

[pcc]

Summary

This change allows clients to generate IR using "files" received from locations
other than the file system. The regular file parser is moved to a new library,
"driver", which is intended to eventually contain much of the logic from
the existing driver.

[axw]

LGTM

CMakeLists.txt

 include(ExternalProject)
 include(ProcessorCount)
 
 llvm_add_go_executable(llgo llvm.org/llgo/cmd/gllgo ALL DEPENDS
   build/context.go
   cmd/gllgo/gllgo.go
   debug/debug.go
+  driver/parser.go
   irgen/annotations.go
   irgen/attribute.go
   irgen/builtins.go
   irgen/cabi.go
   irgen/call.go
   irgen/channels.go
   irgen/closures.go
   irgen/compiler.go
   irgen/errors.go
   irgen/indirect.go
   irgen/interfaces.go
   irgen/maps.go
-  irgen/parser.go
   irgen/predicates.go
   irgen/println.go
   irgen/runtime.go
   irgen/slice.go
   irgen/ssa.go
   irgen/strings.go
   irgen/targets.go
   irgen/typemap.go

cmd/gllgo/gllgo.go

 //===----------------------------------------------------------------------===//
 
 package main
 
 import (
   "errors"
   "fmt"
   "go/scanner"
+  "go/token"
   "io/ioutil"
   "log"
   "os"
   "os/exec"
   "path/filepath"
   "strings"
 
   "llvm.org/llgo/debug"
+  "llvm.org/llgo/driver"
   "llvm.org/llgo/irgen"
   "llvm.org/llvm/bindings/go/llvm"
 )
 
 func report(err error) {
   if list, ok := err.(scanner.ErrorList); ok {
     for _, e := range list {
       fmt.Fprintf(os.Stderr, "%s\n", e)
case actionPrint:
     }
 
   case actionCompile, actionAssemble:
     compiler, err := initCompiler(opts)
     if err != nil {
       return err
     }
 
-    module, err := compiler.Compile(inputs, opts.pkgpath)
+    fset := token.NewFileSet()
+    files, err := driver.ParseFiles(fset, inputs)
+    if err != nil {
+      return err
+    }
+
+    module, err := compiler.Compile(fset, files, opts.pkgpath)
     if err != nil {
       return err
     }
 
     defer module.Dispose()
 
     target, err := llvm.GetTargetFromTriple(opts.triple)
     if err != nil {

driver/parser.go

 //===- parser.go - parser wrapper -----------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file contains functions for calling the parser in an appropriate way for
 // llgo.
 //
 //===----------------------------------------------------------------------===//
 
-package irgen
+package driver
 
 import (
   "fmt"
   "go/ast"
   "go/parser"
   "go/scanner"
   "go/token"
 )
 
 func parseFile(fset *token.FileSet, filename string) (*ast.File, error) {
+  // Retain comments; this is important for annotation processing.
   mode := parser.DeclarationErrors | parser.ParseComments
   return parser.ParseFile(fset, filename, nil, mode)
 }
 
-func parseFiles(fset *token.FileSet, filenames []string) ([]*ast.File, error) {
+func ParseFiles(fset *token.FileSet, filenames []string) ([]*ast.File, error) {
   files := make([]*ast.File, len(filenames))
   for i, filename := range filenames {
     file, err := parseFile(fset, filename)
     if _, ok := err.(scanner.ErrorList); ok {
       return nil, err
     } else if err != nil {
       return nil, fmt.Errorf("%q: %v", filename, err)
     }
     files[i] = file
   }
   return files, nil
 }

irgen/compiler.go

 //
 //===----------------------------------------------------------------------===//
 
 package irgen
 
 import (
   "bytes"
   "fmt"
+  "go/ast"
   "go/token"
   "log"
   "sort"
   "strconv"
   "strings"
 
   llgobuild "llvm.org/llgo/build"
   "llvm.org/llgo/debug"
func NewCompiler(opts CompilerOptions) (*Compiler, error) {
   dataLayout, err := llvmDataLayout(compiler.opts.TargetTriple)
   if err != nil {
     return nil, err
   }
   compiler.dataLayout = dataLayout
   return compiler, nil
 }
 
-func (c *Compiler) Compile(filenames []string, importpath string) (m *Module, err error) {
+func (c *Compiler) Compile(fset *token.FileSet, astFiles []*ast.File, importpath string) (m *Module, err error) {
   target := llvm.NewTargetData(c.dataLayout)
   compiler := &compiler{
     CompilerOptions: c.opts,
     dataLayout:      c.dataLayout,
     target:          target,
     pnacl:           c.pnacl,
     llvmtypes:       NewLLVMTypeMap(llvm.GlobalContext(), target),
   }
-  return compiler.compile(filenames, importpath)
+  return compiler.compile(fset, astFiles, importpath)
 }
 
 type compiler struct {
   CompilerOptions
 
   module     *Module
   dataLayout string
   target     llvm.TargetData

 func (c *compiler) addCommonFunctionAttrs(fn llvm.Value) {
   fn.AddTargetDependentFunctionAttr("disable-tail-calls", "true")
   fn.AddTargetDependentFunctionAttr("split-stack", "")
   if attr := c.SanitizerAttribute; attr != 0 {
     fn.AddFunctionAttr(attr)
   }
 }
 
-func (compiler *compiler) compile(filenames []string, importpath string) (m *Module, err error) {
+func (compiler *compiler) compile(fset *token.FileSet, astFiles []*ast.File, importpath string) (m *Module, err error) {
   buildctx, err := llgobuild.ContextFromTriple(compiler.TargetTriple)
   if err != nil {
     return nil, err
   }
 
   initmap := make(map[*types.Package]gccgoimporter.InitData)
   var importer types.Importer
   if compiler.GccgoPath == "" {
     paths := append(append([]string{}, compiler.ImportPaths...), ".")
     importer = gccgoimporter.GetImporter(paths, initmap)
   } else {
     var inst gccgoimporter.GccgoInstallation
     err = inst.InitFromDriver(compiler.GccgoPath)
     if err != nil {
       return nil, err
     }
     importer = inst.GetImporter(compiler.ImportPaths, initmap)
   }
 
   impcfg := &loader.Config{
-    Fset: token.NewFileSet(),
+    Fset: fset,
     TypeChecker: types.Config{
       Import: importer,
       Sizes:  compiler.llvmtypes,
     },
     Build: &buildctx.Context,
   }
-  // Must use parseFiles, so we retain comments;
-  // this is important for annotation processing.
-  astFiles, err := parseFiles(impcfg.Fset, filenames)
-  if err != nil {
-    return nil, err
-  }
   // If no import path is specified, then set the import
   // path to be the same as the package's name.
   if importpath == "" {
     importpath = astFiles[0].Name.String()
   }
   impcfg.CreateFromFiles(importpath, astFiles...)
   iprog, err := impcfg.Load()
   if err != nil {