[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

llgo/trunk/CMakeLists.txt

 include(ExternalProject)
 include(ProcessorCount)
 
 # Provide a config.h which exposes build system information.
 configure_file(
   cmd/gllgo/config.h.cmake
   ${CMAKE_CURRENT_BINARY_DIR}/cmd/gllgo/config.h)
 include_directories(${CMAKE_CURRENT_BINARY_DIR}/cmd/gllgo)
 
 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

llgo/trunk/cmd/gllgo/gllgo.go

 #include "config.h"
 */
 import "C"
 
 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"
 )
 
 const LibDirSuffix = C.LLVM_LIBDIR_SUFFIX
 
 func report(err error) {
   if list, ok := err.(scanner.ErrorList); ok {
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 {

llgo/trunk/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 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) {
+  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
+}

llgo/trunk/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 {

llgo/trunk/irgen/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
-
-import (
-  "fmt"
-  "go/ast"
-  "go/parser"
-  "go/scanner"
-  "go/token"
-)
-
-func parseFile(fset *token.FileSet, filename string) (*ast.File, error) {
-  mode := parser.DeclarationErrors | parser.ParseComments
-  return parser.ParseFile(fset, filename, nil, mode)
-}
-
-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
-}