Added compile flag to produce only the compilation database

Author: cmaglie

cli/compile/compile.go

@@ -35,25 +35,26 @@ import (
 )
 
 var (
-	fqbn               string   // Fully Qualified Board Name, e.g.: arduino:avr:uno.
-	showProperties     bool     // Show all build preferences used instead of compiling.
-	preprocess         bool     // Print preprocessed code to stdout.
-	buildCachePath     string   // Builds of 'core.a' are saved into this path to be cached and reused.
-	buildPath          string   // Path where to save compiled files.
-	buildProperties    []string // List of custom build properties separated by commas. Or can be used multiple times for multiple properties.
-	warnings           string   // Used to tell gcc which warning level to use.
-	verbose            bool     // Turns on verbose mode.
-	quiet              bool     // Suppresses almost every output.
-	vidPid             string   // VID/PID specific build properties.
-	uploadAfterCompile bool     // Upload the binary after the compilation.
-	port               string   // Upload port, e.g.: COM10 or /dev/ttyACM0.
-	verify             bool     // Upload, verify uploaded binary after the upload.
-	exportDir          string   // The compiled binary is written to this file
-	libraries          []string // List of custom libraries paths separated by commas. Or can be used multiple times for multiple libraries paths.
-	optimizeForDebug   bool     // Optimize compile output for debug, not for release
-	programmer         string   // Use the specified programmer to upload
-	clean              bool     // Cleanup the build folder and do not use any cached build
-	exportBinaries     bool     // Copies compiled binaries to sketch folder when true
+	fqbn                    string   // Fully Qualified Board Name, e.g.: arduino:avr:uno.
+	showProperties          bool     // Show all build preferences used instead of compiling.
+	preprocess              bool     // Print preprocessed code to stdout.
+	buildCachePath          string   // Builds of 'core.a' are saved into this path to be cached and reused.
+	buildPath               string   // Path where to save compiled files.
+	buildProperties         []string // List of custom build properties separated by commas. Or can be used multiple times for multiple properties.
+	warnings                string   // Used to tell gcc which warning level to use.
+	verbose                 bool     // Turns on verbose mode.
+	quiet                   bool     // Suppresses almost every output.
+	vidPid                  string   // VID/PID specific build properties.
+	uploadAfterCompile      bool     // Upload the binary after the compilation.
+	port                    string   // Upload port, e.g.: COM10 or /dev/ttyACM0.
+	verify                  bool     // Upload, verify uploaded binary after the upload.
+	exportDir               string   // The compiled binary is written to this file
+	libraries               []string // List of custom libraries paths separated by commas. Or can be used multiple times for multiple libraries paths.
+	optimizeForDebug        bool     // Optimize compile output for debug, not for release
+	programmer              string   // Use the specified programmer to upload
+	clean                   bool     // Cleanup the build folder and do not use any cached build
+	exportBinaries          bool     // Copies compiled binaries to sketch folder when true
+	compilationDatabaseOnly bool     // Only create compilation database without actually compiling
 )
 
 // NewCommand created a new `compile` command
@@ -94,6 +95,7 @@ func NewCommand() *cobra.Command {
 		"List of custom libraries paths separated by commas. Or can be used multiple times for multiple libraries paths.")
 	command.Flags().BoolVar(&optimizeForDebug, "optimize-for-debug", false, "Optional, optimize compile output for debugging, rather than for release.")
 	command.Flags().StringVarP(&programmer, "programmer", "P", "", "Optional, use the specified programmer to upload.")
+	command.Flags().BoolVar(&compilationDatabaseOnly, "only-compilation-database", false, "Just produce the compilation database, without actually compiling.")
 	command.Flags().BoolVar(&clean, "clean", false, "Optional, cleanup the build folder and do not use any cached build.")
 	// We must use the following syntax for this flag since it's also bound to settings, we could use the other one too
 	// but it wouldn't make sense since we still must explicitly set the exportBinaries variable by reading from settings.
@@ -127,23 +129,24 @@ func run(cmd *cobra.Command, args []string) {
 	exportBinaries = configuration.Settings.GetBool("sketch.always_export_binaries")
 
 	compileReq := &rpc.CompileReq{
-		Instance:         inst,
-		Fqbn:             fqbn,
-		SketchPath:       sketchPath.String(),
-		ShowProperties:   showProperties,
-		Preprocess:       preprocess,
-		BuildCachePath:   buildCachePath,
-		BuildPath:        buildPath,
-		BuildProperties:  buildProperties,
-		Warnings:         warnings,
-		Verbose:          verbose,
-		Quiet:            quiet,
-		VidPid:           vidPid,
-		ExportDir:        exportDir,
-		Libraries:        libraries,
-		OptimizeForDebug: optimizeForDebug,
-		Clean:            clean,
-		ExportBinaries:   exportBinaries,
+		Instance:                      inst,
+		Fqbn:                          fqbn,
+		SketchPath:                    sketchPath.String(),
+		ShowProperties:                showProperties,
+		Preprocess:                    preprocess,
+		BuildCachePath:                buildCachePath,
+		BuildPath:                     buildPath,
+		BuildProperties:               buildProperties,
+		Warnings:                      warnings,
+		Verbose:                       verbose,
+		Quiet:                         quiet,
+		VidPid:                        vidPid,
+		ExportDir:                     exportDir,
+		Libraries:                     libraries,
+		OptimizeForDebug:              optimizeForDebug,
+		Clean:                         clean,
+		ExportBinaries:                exportBinaries,
+		CreateCompilationDatabaseOnly: compilationDatabaseOnly,
 	}
 	compileOut := new(bytes.Buffer)
 	compileErr := new(bytes.Buffer)

commands/compile/compile.go

@@ -191,6 +191,7 @@ func Compile(ctx context.Context, req *rpc.CompileReq, outStream, errStream io.W
 	builderCtx.ExecStderr = errStream
 	builderCtx.SetLogger(i18n.LoggerToCustomStreams{Stdout: outStream, Stderr: errStream})
 	builderCtx.Clean = req.GetClean()
+	builderCtx.OnlyUpdateCompilationDatabase = req.GetCreateCompilationDatabaseOnly()
 
 	// Use defer() to create an rpc.CompileResp with all the information available at the
 	// moment of return.

legacy/builder/builder_utils/utils.go

@@ -247,21 +247,24 @@ func compileFileWithRecipe(ctx *types.Context, sourcePath *paths.Path, source *p
 	if err != nil {
 		return nil, errors.WithStack(err)
 	}
-	if !objIsUpToDate {
-		command, err := PrepareCommandForRecipe(properties, recipe, false)
-		if err != nil {
-			return nil, errors.WithStack(err)
-		}
-
+	command, err := PrepareCommandForRecipe(properties, recipe, false)
+	if err != nil {
+		return nil, errors.WithStack(err)
+	}
+	if ctx.CompilationDatabase != nil {
+		ctx.CompilationDatabase.ReplaceEntry(source, command)
+	}
+	if !objIsUpToDate && !ctx.OnlyUpdateCompilationDatabase {
 		_, _, err = utils.ExecCommand(ctx, command, utils.ShowIfVerbose /* stdout */, utils.Show /* stderr */)
 		if err != nil {
 			return nil, errors.WithStack(err)
 		}
 	} else if ctx.Verbose {
-		if ctx.CompilationDatabase != nil {
-			ctx.CompilationDatabase.KeepEntry(source)
+		if objIsUpToDate {
+			logger.Println(constants.LOG_LEVEL_INFO, constants.MSG_USING_PREVIOUS_COMPILED_FILE, objectFile)
+		} else {
+			logger.Println("info", "Skipping compile of: {0}", objectFile)
 		}
-		logger.Println(constants.LOG_LEVEL_INFO, constants.MSG_USING_PREVIOUS_COMPILED_FILE, objectFile)
 	}
 
 	return objectFile, nil
@@ -455,10 +458,15 @@ func ArchiveCompiledFiles(ctx *types.Context, buildPath *paths.Path, archiveFile
 	logger := ctx.GetLogger()
 	archiveFilePath := buildPath.JoinPath(archiveFile)
 
-	rebuildArchive := false
+	if ctx.OnlyUpdateCompilationDatabase {
+		if ctx.Verbose {
+			logger.Println("info", "Skipping archive creation of: {0}", archiveFilePath)
+		}
+		return archiveFilePath, nil
+	}
 
 	if archiveFileStat, err := archiveFilePath.Stat(); err == nil {
-
+		rebuildArchive := false
 		for _, objectFile := range objectFilesToArchive {
 			objectFileStat, err := objectFile.Stat()
 			if err != nil || objectFileStat.ModTime().After(archiveFileStat.ModTime()) {

legacy/builder/merge_sketch_with_bootloader.go

@@ -31,6 +31,10 @@ import (
 type MergeSketchWithBootloader struct{}
 
 func (s *MergeSketchWithBootloader) Run(ctx *types.Context) error {
+	if ctx.OnlyUpdateCompilationDatabase {
+		return nil
+	}
+
 	buildProperties := ctx.BuildProperties
 	if !buildProperties.ContainsKey(constants.BUILD_PROPERTIES_BOOTLOADER_NOBLINK) && !buildProperties.ContainsKey(constants.BUILD_PROPERTIES_BOOTLOADER_FILE) {
 		return nil

legacy/builder/phases/core_builder.go

@@ -94,7 +94,9 @@ func compileCore(ctx *types.Context, buildPath *paths.Path, buildCachePath *path
 		archivedCoreName := GetCachedCoreArchiveFileName(buildProperties.Get(constants.BUILD_PROPERTIES_FQBN),
 			buildProperties.Get("compiler.optimization_flags"), realCoreFolder)
 		targetArchivedCore = buildCachePath.Join(archivedCoreName)
-		canUseArchivedCore := !ctx.Clean && !builder_utils.CoreOrReferencedCoreHasChanged(realCoreFolder, targetCoreFolder, targetArchivedCore)
+		canUseArchivedCore := !ctx.OnlyUpdateCompilationDatabase &&
+			!ctx.Clean &&
+			!builder_utils.CoreOrReferencedCoreHasChanged(realCoreFolder, targetCoreFolder, targetArchivedCore)
 
 		if canUseArchivedCore {
 			// use archived core
@@ -116,7 +118,7 @@ func compileCore(ctx *types.Context, buildPath *paths.Path, buildCachePath *path
 	}
 
 	// archive core.a
-	if targetArchivedCore != nil {
+	if targetArchivedCore != nil && !ctx.OnlyUpdateCompilationDatabase {
 		err := archiveFile.CopyTo(targetArchivedCore)
 		if ctx.Verbose {
 			if err == nil {

legacy/builder/phases/linker.go

@@ -30,6 +30,13 @@ import (
 type Linker struct{}
 
 func (s *Linker) Run(ctx *types.Context) error {
+	if ctx.OnlyUpdateCompilationDatabase {
+		if ctx.Verbose {
+			ctx.GetLogger().Println("info", "Skip linking of final executable.")
+		}
+		return nil
+	}
+
 	objectFilesSketch := ctx.SketchObjectFiles
 	objectFilesLibraries := ctx.LibrariesObjectFiles
 	objectFilesCore := ctx.CoreObjectsFiles

legacy/builder/phases/sizer.go

@@ -32,7 +32,9 @@ type Sizer struct {
 }
 
 func (s *Sizer) Run(ctx *types.Context) error {
-
+	if ctx.OnlyUpdateCompilationDatabase {
+		return nil
+	}
 	if s.SketchError {
 		return nil
 	}

legacy/builder/recipe_runner.go

@@ -53,6 +53,13 @@ func (s *RecipeByPrefixSuffixRunner) Run(ctx *types.Context) error {
 			return errors.WithStack(err)
 		}
 
+		if ctx.OnlyUpdateCompilationDatabase {
+			if ctx.Verbose {
+				ctx.GetLogger().Println("info", "Skipping: {0}", strings.Join(command.Args, " "))
+			}
+			return nil
+		}
+
 		_, _, err = utils.ExecCommand(ctx, command, utils.ShowIfVerbose /* stdout */, utils.Show /* stderr */)
 		if err != nil {
 			return errors.WithStack(err)

legacy/builder/types/context.go

@@ -167,6 +167,8 @@ type Context struct {
 
 	// Compilation Database to build/update
 	CompilationDatabase *builder.CompilationDatabase
+	// Set to true to skip build and produce only Compilation Database
+	OnlyUpdateCompilationDatabase bool
 }
 
 // ExecutableSectionSize represents a section of the executable output file