Sever isolate package's dependency on client/internal.

client/isolate/format.go

 // Copyright 2015 The LUCI Authors. All rights reserved.
 // Use of this source code is governed under the Apache License, Version 2.0
 // that can be found in the LICENSE file.
 
 package isolate
 
 import (
         "bytes"
         "encoding/json"
         "errors"
         "fmt"
         "io"
         "io/ioutil"
         "log"
         "os"
         "path"
         "path/filepath"
         "regexp"
         "sort"
         "strconv"
         "strings"
 
         "go/ast"
         "go/parser"
         "go/token"
 
-        "github.com/luci/luci-go/client/internal/common"
         "github.com/luci/luci-go/common/isolated"
         "github.com/yosuke-furukawa/json5/encoding/json5"
 )
 
 var osPathSeparator = string(os.PathSeparator)
 
 // ReadOnlyValue defines permissions on isolated files.
 type ReadOnlyValue int
 
 // Possible kinds of read only values.
@@ skipping 157 matching lines @@
                 relDir = strings.Replace(relDir, "/", osPathSeparator, -1)
         }
         return config.Command, dependencies, config.ReadOnly, relDir, nil
 }
 
 func loadIncludedIsolate(isolateDir, include string) (*Configs, error) {
         if filepath.IsAbs(include) {
                 return nil, fmt.Errorf("failed to load configuration; absolute include path %s", include)
         }
         includedIsolate := filepath.Clean(filepath.Join(isolateDir, include))
-        if common.IsWindows() && (strings.ToLower(includedIsolate)[0] != strings.ToLower(isolateDir)[0]) {
+        if IsWindows() && (strings.ToLower(includedIsolate)[0] != strings.ToLower(isolateDir)[0]) {
                 return nil, errors.New("can't reference a .isolate file from another drive")
         }
         content, err := ioutil.ReadFile(includedIsolate)
         if err != nil {
                 return nil, err
         }
         return LoadIsolateAsConfig(filepath.Dir(includedIsolate), content)
 }
 
 // Configs represents a processed .isolate file.
@@ skipping 189 matching lines @@
 // a path variable, e.g. the characters '<('.
 func (lhs *ConfigSettings) union(rhs *ConfigSettings) (*ConfigSettings, error) {
         // When an object has IsolateDir == "", it means it is the empty object.
         if lhs.IsolateDir == "" {
                 return rhs, nil
         }
         if rhs.IsolateDir == "" {
                 return lhs, nil
         }
 
-        if common.IsWindows() && strings.ToLower(lhs.IsolateDir)[0] != strings.ToLower(rhs.IsolateDir)[0] {
+        if IsWindows() && strings.ToLower(lhs.IsolateDir)[0] != strings.ToLower(rhs.IsolateDir)[0] {
                 return nil, errors.New("All .isolate files must be on same drive")
         }
 
         // Takes the difference between the two isolateDir. Note that while
         // isolateDir is in native path case, all other references are in posix.
         useRHS := false
         var command []string
         if len(lhs.Command) > 0 {
                 useRHS = false
                 command = lhs.Command
@@ skipping 356 matching lines @@
                 }
                 if err != nil {
                         return false
                 }
                 switch n := n.(type) {
                 case *ast.BinaryExpr:
                         if n.Op == token.LAND || n.Op == token.LOR {
                                 return true
                         }
                         if n.Op != token.EQL {
-                                err = fmt.Errorf("unknown binary operator %s\n", n.Op)
+                                err = fmt.Errorf("unknown binary operator %s", n.Op)
                                 return false
                         }
                         id, value, tmpErr := verifyIDEqualValue(n)
                         if tmpErr != nil {
                                 err = tmpErr
                                 return false
                         }
                         equalityValues[n.Pos()] = value
                         if _, exists := varsAndValues[id]; !exists {
                                 varsAndValues[id] = map[variableValueKey]variableValue{}
                         }
                         varsAndValues[id][value.key()] = value
                         return false
                 case *ast.ParenExpr:
                         return true
                 default:
-                        err = fmt.Errorf("unknown expression type %T\n", n)
+                        err = fmt.Errorf("unknown expression type %T", n)
                         return false
                 }
                 // unreachable
         })
         if err != nil {
                 return nil, fmt.Errorf("invalid Condition: %s", err)
         }
         return equalityValues, nil
 }
 
@@ skipping 246 matching lines @@
         return len(c)
 }
 
 func (c configPairs) Less(i, j int) bool {
         return c[i].key.compare(c[j].key) > 0
 }
 
 func (c configPairs) Swap(i, j int) {
         c[i], c[j] = c[j], c[i]
 }