all

bundle/config/mutator/initialize_urls.go

@@ -32,7 +32,9 @@ func (m *initializeURLs) Apply(ctx context.Context, b *bundle.Bundle) diag.Diagn
 	}
 	orgId := strconv.FormatInt(workspaceId, 10)
 	host := b.WorkspaceClient().Config.CanonicalHostName()
-	initializeForWorkspace(b, orgId, host)
+	if err := initializeForWorkspace(b, orgId, host); err != nil {
+		return diag.FromErr(err)
+	}
 	return nil
 }
 

bundle/config/mutator/resolve_resource_references.go

@@ -36,7 +36,9 @@ func (m *resolveResourceReferences) Apply(ctx context.Context, b *bundle.Bundle)
 				return fmt.Errorf("failed to resolve %s, err: %w", v.Lookup, err)
 			}
 
-			v.Set(id)
+			if err := v.Set(id); err != nil {
+				return err
+			}
 			return nil
 		})
 	}

bundle/deploy/state_pull.go

@@ -62,8 +62,14 @@ func (s *statePull) Apply(ctx context.Context, b *bundle.Bundle) diag.Diagnostic
 	}
 
 	// Truncating the file before writing
-	local.Truncate(0)
-	local.Seek(0, 0)
+	err = local.Truncate(0)
+	if err != nil {
+		return diag.FromErr(err)
+	}
+	_, err = local.Seek(0, 0)
+	if err != nil {
+		return diag.FromErr(err)
+	}
 
 	// Write file to disk.
 	log.Infof(ctx, "Writing remote deployment state file to local cache directory")

bundle/libraries/upload_test.go

@@ -23,7 +23,7 @@ func TestArtifactUploadForWorkspace(t *testing.T) {
 	tmpDir := t.TempDir()
 	whlFolder := filepath.Join(tmpDir, "whl")
 	testutil.Touch(t, whlFolder, "source.whl")
-	whlLocalPath := filepath.Join(whlFolder, "source.whl")
+	_ = filepath.Join(whlFolder, "source.whl")
 
 	b := &bundle.Bundle{
 		SyncRootPath: tmpDir,
@@ -32,10 +32,10 @@ func TestArtifactUploadForWorkspace(t *testing.T) {
 				ArtifactPath: "/foo/bar/artifacts",
 			},
 			Artifacts: config.Artifacts{
-				"whl": {
+				"whl": &config.Artifact{
 					Type: config.ArtifactPythonWheel,
 					Files: []config.ArtifactFile{
-						{Source: whlLocalPath},
+						{Source: filepath.Join(whlFolder, "source.whl")},
 					},
 				},
 			},
@@ -111,7 +111,7 @@ func TestArtifactUploadForVolumes(t *testing.T) {
 	tmpDir := t.TempDir()
 	whlFolder := filepath.Join(tmpDir, "whl")
 	testutil.Touch(t, whlFolder, "source.whl")
-	whlLocalPath := filepath.Join(whlFolder, "source.whl")
+	_ = filepath.Join(whlFolder, "source.whl")
 
 	b := &bundle.Bundle{
 		SyncRootPath: tmpDir,
@@ -120,10 +120,10 @@ func TestArtifactUploadForVolumes(t *testing.T) {
 				ArtifactPath: "/Volumes/foo/bar/artifacts",
 			},
 			Artifacts: config.Artifacts{
-				"whl": {
+				"whl": &config.Artifact{
 					Type: config.ArtifactPythonWheel,
 					Files: []config.ArtifactFile{
-						{Source: whlLocalPath},
+						{Source: filepath.Join(whlFolder, "source.whl")},
 					},
 				},
 			},

bundle/render/render_text_output.go

@@ -171,10 +171,14 @@ func RenderDiagnostics(out io.Writer, b *bundle.Bundle, diags diag.Diagnostics,
 			if err != nil {
 				return fmt.Errorf("failed to render summary: %w", err)
 			}
-			io.WriteString(out, "\n")
+			if _, err := io.WriteString(out, "\n"); err != nil {
+				return err
+			}
 		}
 		trailer := buildTrailer(diags)
-		io.WriteString(out, trailer)
+		if _, err := io.WriteString(out, trailer); err != nil {
+			return err
+		}
 	}
 
 	return nil

cmd/auth/describe.go

@@ -141,7 +141,9 @@ func render(ctx context.Context, cmd *cobra.Command, status *authStatus, templat
 		if err != nil {
 			return err
 		}
-		cmd.OutOrStdout().Write(buf)
+		if _, err := cmd.OutOrStdout().Write(buf); err != nil {
+			return err
+		}
 	default:
 		return fmt.Errorf("unknown output type %s", root.OutputType(cmd))
 	}

cmd/bundle/debug/terraform.go

@@ -60,13 +60,19 @@ For more information about filesystem mirrors, see the Terraform documentation:
 		}
 		switch root.OutputType(cmd) {
 		case flags.OutputText:
-			cmdio.Render(cmd.Context(), dependencies.Terraform)
+			err := cmdio.Render(cmd.Context(), dependencies.Terraform)
+			if err != nil {
+				return err
+			}
 		case flags.OutputJSON:
 			buf, err := json.MarshalIndent(dependencies, "", "  ")
 			if err != nil {
 				return err
 			}
-			cmd.OutOrStdout().Write(buf)
+			_, err = cmd.OutOrStdout().Write(buf)
+			if err != nil {
+				return err
+			}
 		default:
 			return fmt.Errorf("unknown output type %s", root.OutputType(cmd))
 		}

cmd/bundle/deploy.go

@@ -33,10 +33,14 @@ func newDeployCommand() *cobra.Command {
 	cmd.Flags().StringVar(&clusterId, "compute-id", "", "Override cluster in the deployment with the given compute ID.")
 	cmd.Flags().StringVarP(&clusterId, "cluster-id", "c", "", "Override cluster in the deployment with the given cluster ID.")
 	cmd.Flags().BoolVar(&autoApprove, "auto-approve", false, "Skip interactive approvals that might be required for deployment.")
-	cmd.Flags().MarkDeprecated("compute-id", "use --cluster-id instead")
+	if err := cmd.Flags().MarkDeprecated("compute-id", "use --cluster-id instead"); err != nil {
+		return nil
+	}
 	cmd.Flags().BoolVar(&verbose, "verbose", false, "Enable verbose output.")
 	// Verbose flag currently only affects file sync output, it's used by the vscode extension
-	cmd.Flags().MarkHidden("verbose")
+	if err := cmd.Flags().MarkHidden("verbose"); err != nil {
+		return nil
+	}
 
 	cmd.RunE = func(cmd *cobra.Command, args []string) error {
 		ctx := cmd.Context()

cmd/bundle/run.go

@@ -159,13 +159,17 @@ task or a Python wheel task, the second example applies.
 				if err != nil {
 					return err
 				}
-				cmd.OutOrStdout().Write([]byte(resultString))
+				if _, err := cmd.OutOrStdout().Write([]byte(resultString)); err != nil {
+					return err
+				}
 			case flags.OutputJSON:
 				b, err := json.MarshalIndent(output, "", "  ")
 				if err != nil {
 					return err
 				}
-				cmd.OutOrStdout().Write(b)
+				if _, err := cmd.OutOrStdout().Write(b); err != nil {
+					return err
+				}
 			default:
 				return fmt.Errorf("unknown output type %s", root.OutputType(cmd))
 			}

cmd/configure/flags.go

@@ -21,5 +21,8 @@ func (f *configureFlags) Register(cmd *cobra.Command) {
 	// Include token flag for compatibility with the legacy CLI.
 	// It doesn't actually do anything because we always use PATs.
 	cmd.Flags().Bool("token", true, "Configure using Databricks Personal Access Token")
-	cmd.Flags().MarkHidden("token")
+	err := cmd.Flags().MarkHidden("token")
+	if err != nil {
+		panic(err)
+	}
 }

cmd/root/auth.go

@@ -37,7 +37,9 @@ func (e ErrNoAccountProfiles) Error() string {
 
 func initProfileFlag(cmd *cobra.Command) {
 	cmd.PersistentFlags().StringP("profile", "p", "", "~/.databrickscfg profile")
-	cmd.RegisterFlagCompletionFunc("profile", profile.ProfileCompletion)
+	if err := cmd.RegisterFlagCompletionFunc("profile", profile.ProfileCompletion); err != nil {
+		panic(err)
+	}
 }
 
 func profileFlagValue(cmd *cobra.Command) (string, bool) {

cmd/root/bundle.go

@@ -146,13 +146,19 @@ func targetCompletion(cmd *cobra.Command, args []string, toComplete string) ([]s
 func initTargetFlag(cmd *cobra.Command) {
 	// To operate in the context of a bundle, all commands must take an "target" parameter.
 	cmd.PersistentFlags().StringP("target", "t", "", "bundle target to use (if applicable)")
-	cmd.RegisterFlagCompletionFunc("target", targetCompletion)
+	if err := cmd.RegisterFlagCompletionFunc("target", targetCompletion); err != nil {
+		panic(err)
+	}
 }
 
 // DEPRECATED flag
 func initEnvironmentFlag(cmd *cobra.Command) {
 	// To operate in the context of a bundle, all commands must take an "environment" parameter.
 	cmd.PersistentFlags().StringP("environment", "e", "", "bundle target to use (if applicable)")
-	cmd.PersistentFlags().MarkDeprecated("environment", "use --target flag instead")
-	cmd.RegisterFlagCompletionFunc("environment", targetCompletion)
+	if err := cmd.PersistentFlags().MarkDeprecated("environment", "use --target flag instead"); err != nil {
+		panic(err)
+	}
+	if err := cmd.RegisterFlagCompletionFunc("environment", targetCompletion); err != nil {
+		panic(err)
+	}
 }

cmd/root/io.go

@@ -21,7 +21,9 @@ func initOutputFlag(cmd *cobra.Command) *outputFlag {
 	// Configure defaults from environment, if applicable.
 	// If the provided value is invalid it is ignored.
 	if v, ok := env.Lookup(cmd.Context(), envOutputFormat); ok {
-		f.output.Set(v)
+		if err := f.output.Set(v); err != nil {
+			panic(err)
+		}
 	}
 
 	cmd.PersistentFlags().VarP(&f.output, "output", "o", "output type: text or json")

cmd/root/logger.go

@@ -45,7 +45,9 @@ func (f *logFlags) makeLogHandler(opts slog.HandlerOptions) (slog.Handler, error
 
 func (f *logFlags) initializeContext(ctx context.Context) (context.Context, error) {
 	if f.debug {
-		f.level.Set("debug")
+		if err := f.level.Set("debug"); err != nil {
+			panic(err)
+		}
 	}
 
 	opts := slog.HandlerOptions{}
@@ -81,13 +83,19 @@ func initLogFlags(cmd *cobra.Command) *logFlags {
 	// Configure defaults from environment, if applicable.
 	// If the provided value is invalid it is ignored.
 	if v, ok := env.Lookup(cmd.Context(), envLogFile); ok {
-		f.file.Set(v)
+		if err := f.file.Set(v); err != nil {
+			panic(err)
+		}
 	}
 	if v, ok := env.Lookup(cmd.Context(), envLogLevel); ok {
-		f.level.Set(v)
+		if err := f.level.Set(v); err != nil {
+			panic(err)
+		}
 	}
 	if v, ok := env.Lookup(cmd.Context(), envLogFormat); ok {
-		f.output.Set(v)
+		if err := f.output.Set(v); err != nil {
+			panic(err)
+		}
 	}
 
 	flags := cmd.PersistentFlags()
@@ -97,12 +105,24 @@ func initLogFlags(cmd *cobra.Command) *logFlags {
 	flags.Var(&f.output, "log-format", "log output format (text or json)")
 
 	// mark fine-grained flags hidden from global --help
-	flags.MarkHidden("log-file")
-	flags.MarkHidden("log-level")
-	flags.MarkHidden("log-format")
+	if err := flags.MarkHidden("log-file"); err != nil {
+		panic(err)
+	}
+	if err := flags.MarkHidden("log-level"); err != nil {
+		panic(err)
+	}
+	if err := flags.MarkHidden("log-format"); err != nil {
+		panic(err)
+	}
 
-	cmd.RegisterFlagCompletionFunc("log-file", f.file.Complete)
-	cmd.RegisterFlagCompletionFunc("log-level", f.level.Complete)
-	cmd.RegisterFlagCompletionFunc("log-format", f.output.Complete)
+	if err := cmd.RegisterFlagCompletionFunc("log-file", f.file.Complete); err != nil {
+		panic(err)
+	}
+	if err := cmd.RegisterFlagCompletionFunc("log-level", f.level.Complete); err != nil {
+		panic(err)
+	}
+	if err := cmd.RegisterFlagCompletionFunc("log-format", f.output.Complete); err != nil {
+		panic(err)
+	}
 	return &f
 }

cmd/root/progress_logger.go

@@ -59,12 +59,16 @@ func initProgressLoggerFlag(cmd *cobra.Command, logFlags *logFlags) *progressLog
 	// Configure defaults from environment, if applicable.
 	// If the provided value is invalid it is ignored.
 	if v, ok := env.Lookup(cmd.Context(), envProgressFormat); ok {
-		f.Set(v)
+		if err := f.ProgressLogFormat.Set(v); err != nil {
+			panic(err)
+		}
 	}
 
 	flags := cmd.PersistentFlags()
 	flags.Var(&f.ProgressLogFormat, "progress-format", "format for progress logs (append, inplace, json)")
-	flags.MarkHidden("progress-format")
+	if err := flags.MarkHidden("progress-format"); err != nil {
+		panic(err)
+	}
 	cmd.RegisterFlagCompletionFunc("progress-format", f.ProgressLogFormat.Complete)
 	return &f
 }

libs/auth/callback.go

@@ -53,7 +53,11 @@ func newCallback(ctx context.Context, a *PersistentAuth) (*callbackServer, error
 		a:           a,
 	}
 	cb.srv.Handler = cb
-	go cb.srv.Serve(cb.ln)
+	go func() {
+		if err := cb.srv.Serve(cb.ln); err != http.ErrServerClosed {
+			panic(err)
+		}
+	}()
 	return cb, nil
 }
 

libs/cmdio/logger.go

@@ -188,23 +188,35 @@ func (l *Logger) writeJson(event Event) {
 		// we panic because there we cannot catch this in jobs.RunNowAndWait
 		panic(err)
 	}
-	l.Writer.Write([]byte(b))
-	l.Writer.Write([]byte("\n"))
+	if _, err := l.Writer.Write([]byte(b)); err != nil {
+		panic(err)
+	}
+	if _, err := l.Writer.Write([]byte("\n")); err != nil {
+		panic(err)
+	}
 }
 
 func (l *Logger) writeAppend(event Event) {
-	l.Writer.Write([]byte(event.String()))
-	l.Writer.Write([]byte("\n"))
+	if _, err := l.Writer.Write([]byte(event.String())); err != nil {
+		panic(err)
+	}
+	if _, err := l.Writer.Write([]byte("\n")); err != nil {
+		panic(err)
+	}
 }
 
 func (l *Logger) writeInplace(event Event) {
 	if l.isFirstEvent {
 		// save cursor location
-		l.Writer.Write([]byte("\033[s"))
+		if _, err := l.Writer.Write([]byte("\033[s")); err != nil {
+			panic(err)
+		}
 	}
 
 	// move cursor to saved location
-	l.Writer.Write([]byte("\033[u"))
+	if _, err := l.Writer.Write([]byte("\033[u")); err != nil {
+		panic(err)
+	}
 
 	// clear from cursor to end of screen
 	l.Writer.Write([]byte("\033[0J"))

libs/cmdio/render.go

@@ -361,7 +361,9 @@ func renderUsingTemplate(ctx context.Context, r templateRenderer, w io.Writer, h
 		if err != nil {
 			return err
 		}
-		tw.Write([]byte("\n"))
+		if _, err := tw.Write([]byte("\n")); err != nil {
+			return err
+		}
 		// Do not flush here. Instead, allow the first 100 resources to determine the initial spacing of the header columns.
 	}
 	t, err := base.Parse(tmpl)

libs/dyn/convert/from_typed.go

@@ -126,7 +126,9 @@ func fromTypedStruct(src reflect.Value, ref dyn.Value, options ...fromTypedOptio
 
 		// Either if the key was set in the reference or the field is not zero-valued, we include it.
 		if ok || nv.Kind() != dyn.KindNil {
-			out.Set(refk, nv)
+			if err := out.Set(refk, nv); err != nil {
+				return dyn.InvalidValue, err
+			}
 		}
 	}
 
@@ -184,7 +186,9 @@ func fromTypedMap(src reflect.Value, ref dyn.Value) (dyn.Value, error) {
 
 		// Every entry is represented, even if it is a nil.
 		// Otherwise, a map with zero-valued structs would yield a nil as well.
-		out.Set(refk, nv)
+		if err := out.Set(refk, nv); err != nil {
+			return dyn.InvalidValue, err
+		}
 	}
 
 	return dyn.V(out), nil

libs/dyn/convert/normalize.go

@@ -116,7 +116,12 @@ func (n normalizeOptions) normalizeStruct(typ reflect.Type, src dyn.Value, seen
 				}
 			}
 
-			out.Set(pk, nv)
+			if err := out.Set(pk, nv); err != nil {
+				return dyn.InvalidValue, diag.Diagnostics{diag.Diagnostic{
+					Severity: diag.Error,
+					Summary:  err.Error(),
+				}}
+			}
 		}
 
 		// Return the normalized value if missing fields are not included.
@@ -162,7 +167,9 @@ func (n normalizeOptions) normalizeStruct(typ reflect.Type, src dyn.Value, seen
 				continue
 			}
 			if v.IsValid() {
-				out.Set(dyn.V(k), v)
+				if err := out.Set(dyn.V(k), v); err != nil {
+					return dyn.InvalidValue, diag.FromErr(err)
+				}
 			}
 		}
 
@@ -201,7 +208,9 @@ func (n normalizeOptions) normalizeMap(typ reflect.Type, src dyn.Value, seen []r
 				}
 			}
 
-			out.Set(pk, nv)
+			if err := out.Set(pk, nv); err != nil {
+				return dyn.InvalidValue, diag.FromErr(err)
+			}
 		}
 
 		return dyn.NewValue(out, src.Locations()), diags

libs/dyn/jsonloader/json.go

@@ -70,7 +70,9 @@ func decodeValue(decoder *json.Decoder, o *Offset) (dyn.Value, error) {
 					return invalidValueWithLocation(decoder, o), err
 				}
 
-				obj.Set(keyVal, val)
+				if err := obj.Set(keyVal, val); err != nil {
+					return invalidValueWithLocation(decoder, o), err
+				}
 			}
 			// Consume the closing '}'
 			if _, err := decoder.Token(); err != nil {

libs/dyn/mapping.go

@@ -41,7 +41,9 @@ func newMappingWithSize(size int) Mapping {
 func newMappingFromGoMap(vin map[string]Value) Mapping {
 	m := newMappingWithSize(len(vin))
 	for k, v := range vin {
-		m.Set(V(k), v)
+		if err := m.Set(V(k), v); err != nil {
+			panic(err)
+		}
 	}
 	return m
 }
@@ -144,6 +146,8 @@ func (m Mapping) Clone() Mapping {
 // Merge merges the key-value pairs from another Mapping into the current Mapping.
 func (m *Mapping) Merge(n Mapping) {
 	for _, p := range n.pairs {
-		m.Set(p.Key, p.Value)
+		if err := m.Set(p.Key, p.Value); err != nil {
+			panic(err)
+		}
 	}
 }

libs/dyn/merge/merge.go

@@ -88,10 +88,14 @@ func mergeMap(a, b dyn.Value) (dyn.Value, error) {
 			if err != nil {
 				return dyn.InvalidValue, err
 			}
-			out.Set(pk, merged)
+			if err := out.Set(pk, merged); err != nil {
+				return dyn.InvalidValue, err
+			}
 		} else {
 			// Otherwise, just set the value.
-			out.Set(pk, pv)
+			if err := out.Set(pk, pv); err != nil {
+				return dyn.InvalidValue, err
+			}
 		}
 	}
 

libs/dyn/pattern.go

@@ -69,7 +69,9 @@ func (c anyKeyComponent) visit(v Value, prefix Path, suffix Pattern, opts visitO
 			return InvalidValue, err
 		}
 
-		m.Set(pk, nv)
+		if err := m.Set(pk, nv); err != nil {
+			panic(err)
+		}
 	}
 
 	return NewValue(m, v.Locations()), nil

libs/dyn/visit.go

@@ -122,7 +122,9 @@ func (component pathComponent) visit(v Value, prefix Path, suffix Pattern, opts
 
 		// Return an updated map value.
 		m = m.Clone()
-		m.Set(V(component.key), nv)
+		if err := m.Set(V(component.key), nv); err != nil {
+			return InvalidValue, err
+		}
 		return Value{
 			v: m,
 			k: KindMap,

libs/dyn/visit_map.go

@@ -25,7 +25,9 @@ func Foreach(fn MapFunc) MapFunc {
 				if err != nil {
 					return InvalidValue, err
 				}
-				m.Set(pk, nv)
+				if err := m.Set(pk, nv); err != nil {
+					return InvalidValue, err
+				}
 			}
 			return NewValue(m, v.Locations()), nil
 		case KindSequence:

libs/dyn/visit_set.go

@@ -41,7 +41,9 @@ func SetByPath(v Value, p Path, nv Value) (Value, error) {
 
 				// Return an updated map value.
 				m = m.Clone()
-				m.Set(V(component.key), nv)
+				if err := m.Set(V(component.key), nv); err != nil {
+					return InvalidValue, err
+				}
 				return Value{
 					v: m,
 					k: KindMap,

libs/dyn/walk.go

@@ -45,7 +45,9 @@ func walk(v Value, p Path, fn func(p Path, v Value) (Value, error)) (Value, erro
 			if err != nil {
 				return InvalidValue, err
 			}
-			out.Set(pk, nv)
+			if err := out.Set(pk, nv); err != nil {
+				panic(err)
+			}
 		}
 		v.v = out
 	case KindSequence:

libs/dyn/yamlloader/loader.go

@@ -129,7 +129,9 @@ func (d *loader) loadMapping(node *yaml.Node, loc dyn.Location) (dyn.Value, erro
 			return dyn.InvalidValue, err
 		}
 
-		acc.Set(k, v)
+		if err := acc.Set(k, v); err != nil {
+			return dyn.InvalidValue, err
+		}
 	}
 
 	if merge == nil {

libs/env/loader.go

@@ -43,7 +43,9 @@ func (le *configLoader) Configure(cfg *config.Config) error {
 			if v == "" {
 				continue
 			}
-			a.Set(cfg, v)
+			if err := a.Set(cfg, v); err != nil {
+				return err
+			}
 		}
 	}
 	return nil

libs/git/config.go

@@ -155,8 +155,12 @@ func globalGitConfig() (*config, error) {
 	// > are missing or unreadable they will be ignored.
 	//
 	// We therefore ignore the error return value for the calls below.
-	config.loadFile(vfs.MustNew(xdgConfigHome), "git/config")
-	config.loadFile(vfs.MustNew(config.home), ".gitconfig")
+	if err := config.loadFile(vfs.MustNew(xdgConfigHome), "git/config"); err != nil {
+		return nil, err
+	}
+	if err := config.loadFile(vfs.MustNew(config.home), ".gitconfig"); err != nil {
+		return nil, err
+	}
 
 	return config, nil
 }

libs/process/stub.go

@@ -149,10 +149,14 @@ func (s *processStub) run(cmd *exec.Cmd) error {
 			continue
 		}
 		if resp.stdout != "" {
-			cmd.Stdout.Write([]byte(resp.stdout))
+			if _, err := cmd.Stdout.Write([]byte(resp.stdout)); err != nil {
+				return err
+			}
 		}
 		if resp.stderr != "" {
-			cmd.Stderr.Write([]byte(resp.stderr))
+			if _, err := cmd.Stderr.Write([]byte(resp.stderr)); err != nil {
+				return err
+			}
 		}
 		return resp.err
 	}
@@ -164,7 +168,9 @@ func (s *processStub) run(cmd *exec.Cmd) error {
 		return fmt.Errorf("no default process stub")
 	}
 	if s.reponseStub.stdout != "" {
-		cmd.Stdout.Write([]byte(s.reponseStub.stdout))
+		if _, err := cmd.Stdout.Write([]byte(s.reponseStub.stdout)); err != nil {
+			return err
+		}
 	}
 	return s.reponseStub.err
 }

libs/sync/output.go

@@ -43,9 +43,18 @@ func TextOutput(ctx context.Context, ch <-chan Event, w io.Writer) {
 			// Log only if something actually happened.
 			// Sync events produce an empty string if nothing happened.
 			if str := e.String(); str != "" {
-				bw.WriteString(str)
-				bw.WriteString("\n")
-				bw.Flush()
+				_, err := bw.WriteString(str)
+				if err != nil {
+					panic(err)
+				}
+				_, err = bw.WriteString("\n")
+				if err != nil {
+					panic(err)
+				}
+				err = bw.Flush()
+				if err != nil {
+					panic(err)
+				}
 			}
 		}
 	}