Ticket #111: utilsToExtns.patch

Source/TypeProxies.cobra

@@ -380 +380 @@
         Also, implements -correct-source:case or suggests it if it is off, but would have resolved.
         """
         # don't need to check "basic types" like int, bool, etc. here. the parser does those.
-        if Utils.isCapped(name)
+        if name.isCapped
             symbol = .compiler.symbolForName(name, true, false)  # nested enum and class types are capped and can be members of the current class
         else
             symbol = nil
         if symbol is nil
             correctCase = 'case' in .compiler.options.setValue('correct-source')
             if correctCase
-                if not Utils.isCapped(name)
+                if not name.isCapped
                     # not very sophisticated, but catches 'string', 'object', etc.
                     name = name.capped
                     symbol = .compiler.symbolForName(name, true, false)
@@ -399 +399 @@
                         .compiler.correctSource(.token, name)
             if symbol is nil
                 sugg = Compiler.suggestionFor(name) ? ''
-                if sugg == '' and not Utils.isCapped(name)
+                if sugg == '' and not name.isCapped
                     other = .compiler.symbolForName(name.capped, true, false)
                     if other, sugg = name.capped
                 if sugg <> '', sugg = ' Try "[sugg]". Also, consider the -correct-source option (see cobra -h for details).'

Source/Expr.cobra

@@ -860 +860 @@
         """
 
     cue init(token as IToken, name as String, args as List<of Expr>, definition as EnumDecl)
-        require Utils.isCapped(name)
+        require name.isCapped
         base.init(token)
         _name = name
         _args = args

Source/Parser.cobra

@@ -145 +145 @@
         if _willShowTokens
             print 'expect([whatTypes]) --> [t]'
         if t is nil
-            .throwError('Expecting [Utils.join(" or ",whatTypes)], but source ended suddenly.')
+            .throwError('Expecting [" or ".join(whatTypes)], but source ended suddenly.')
         if t.which not in whatTypes
-            .throwError('Expecting [Utils.join(" or ",whatTypes)], but got [t] instead.')
+            .throwError('Expecting [" or ".join(whatTypes)], but got [t] instead.')
         return t to !
 
     def optional(whatTypes as vari String) as IToken?

Source/BackEndClr/SharpGenerator.cobra

@@ -145 +145 @@
                 backEndOptions += ' [optChar]target:[target]'
                 # TODO: what is the output for a module?
                 branch target
-                    on 'exe' or 'winexe', outName = Utils.forceExtension(outName, '.exe')
-                    on 'library', outName = Utils.forceExtension(outName, '.dll')
-                    on 'module', outName = Utils.forceExtension(outName, '.netmodule')  # http://msdn2.microsoft.com/en-us/library/58scf68s(VS.80).aspx
+                    on 'exe' or 'winexe', outName = Utils.pathForceExtension(outName, '.exe')
+                    on 'library', outName = Utils.pathForceExtension(outName, '.dll')
+                    on 'module', outName = Utils.pathForceExtension(outName, '.netmodule')  # http://msdn2.microsoft.com/en-us/library/58scf68s(VS.80).aspx
                     else, throw FallThroughException(target)
             else
-                outName = Utils.forceExtension(outName, '.exe')
+                outName = Utils.pathForceExtension(outName, '.exe')
             _fullExeFileName = outName
 
             delaySign = options.boolValue('delay-sign')
@@ -233 +233 @@
                 # use Process class instead of CSharpCodeProvider because the user specified a path to a C# compiler
                 p = System.Diagnostics.Process()
                 p.startInfo.fileName = cscPath
-                sharpFileNames = Utils.join(' ', for fileName in sharpFileNameList get '"' + fileName + '"')
+                sharpFileNames = ' '.join( for fileName in sharpFileNameList get '"' + fileName + '"')
                 p.startInfo.arguments = '[backEndOptions] [sharpFileNames]'
                 if _verbosity >= 2
                     print '[p.startInfo.fileName] [p.startInfo.arguments]'
@@ -281 +281 @@
                     # otherwise, the first element is the C# compilation line
                     if _verbosity >= 2 and cr.output.count > 0
                         print '>>', cr.output[0], '<<'
-                    output = if(cr.output.count==0, '', Utils.join('\n', cr.output[1:]).trim)
+                    output = if(cr.output.count==0, '', '\n'.join(cr.output[1:]).trim)
                     # trace output
                     _parseSharpCompilerOutput(output)
 
@@ -396 +396 @@
         if false
             # kind of silly, but it works:
             d = Dictionary<of int, int>()
-            for i = 1 .. Utils.countChars(File.readAllText(_sharpFileName), c'\n')+1
+            for i in 1 : File.readAllText(_sharpFileName).countChars(c'\n')+1
                 d[i] = i
             return d    
         return nil
@@ -508 +508 @@
         }
         sep = ''
         for name in isNames
-            name = Utils.getSS(isNameCS to passthrough, name, name) to !
+            name = Utils.dictGetVOD<of String>(isNameCS to passthrough, name, name)
             sw.write(sep)
             sw.write(name)
             sep = ' '
@@ -1432 +1432 @@
         wroteNames = Set<of String>()
         sep = ''
         for name in _isNames
-            name = Utils.getSS(isNameCS, name, name) to !
+            name = Utils.dictGetVOD<of String>(isNameCS, name, name)# to !
             sw.write(sep)
             sw.write(name)
             sep = ' '

Source/BackEndClr/ScanClrType.cobra

@@ -54 +54 @@
                     .warning(CobraWarning('Already have declaration "[clrType.name]" in namespace "[curNameSpace.fullName]".'))
                 else
                     if type.isClass
-                        if type.name.startsWith('Extend_') and Utils.countChars(type.name, c'_') >= 2
+                        if type.name.startsWith('Extend_') and type.name.countChars(c'_') >= 2
                             curNameSpace.addDecl(Extension(clrType))
                         else
                             curNameSpace.addDecl(Class(clrType))

Source/BackEndJvm/JavaGenerator.cobra

@@ -114 +114 @@
         if false
             # kind of silly, but it works:
             d = Dictionary<of int, int>()
-            for i in 1 : Utils.countChars(File.readAllText(_javaFileName), c'\n')+1
+            for i in 1 : File.readAllText(_javaFileName).countChars(c'\n')+1
                 d[i] = i
             return d    
         return nil
@@ -229 +229 @@
         }
         sep = ''
         for name in isNames
-            name = Utils.getSS(isNameJava to passthrough, name, name) to !
+            name = Utils.dictGetVOD<of String>(isNameJava to passthrough, name, name)
             sw.write(sep)
             sw.write(name)
             sep = ' '

Source/CobraTokenizer.cobra

@@ -354 +354 @@
         assert tok.text.endsWith(' ')
         # this is okay on continued lines
         if .justDidLineContinuation
-            indentLevel = Utils.countChars(tok.text, c'\t') + Utils.countChars(tok.text, c' ') // 4
+            indentLevel = tok.text.countChars(c'\t') + tok.text.countChars(c' ') // 4
             return _processNumIndentLevels(indentLevel)  # will check continuation indentation rules
         else
             return .onINDENT_MIXED_TS(tok)
@@ -375 +375 @@
         return .onINDENT_MIXED_TS(tok)
 
     def onINDENT_ALL_TABS(tok as IToken) as IToken?
-        numTabs = Utils.countChars(tok.text, c'\t')
+        numTabs = tok.text.countChars(c'\t')
         return _processNumIndentLevels(numTabs)
 
     def onINDENT_ALL_SPACES(tok as IToken) as IToken?
-        numSpaces = Utils.countChars(tok.text, c' ')
+        numSpaces = tok.text.countChars(c' ')
         if numSpaces % 4 and not .justDidLineContinuation # yes, 4. hard coded, intentionally.
             # TODO: should really just record an error and take (numSpaces/4).round as the indent
             .throwError('Space-based indentation must be a multiple of 4. This line has a remainder of [numSpaces%4].')

Source/Compiler.cobra

@@ -567 +567 @@
             hasSpaces = any for a in argList where ' ' in a
             if hasSpaces
                 argList = for arg in argList get if(' ' in arg, '"[arg]"', arg)
-            args += Utils.join(' ', argList) 
+            args += ' '.join(argList) 
             p.startInfo.arguments = args
         return p
 

Source/Tokenizer.cobra

@@ -585 +585 @@
             if _sourceLine is nil
                 # end of source
                 return false
-            numLines = Utils.countChars(_sourceLine to !, c'\n')
+            numLines = (_sourceLine to !).countChars( c'\n')
             if numLines == 0 and _willAlwaysEndWithNewLine
                 _sourceLine += "\n"
             #trace sourceLine

Source/Boxes.cobra

@@ -232 +232 @@
                 assert ns is not ns.superNameSpace
                 ns = ns.superNameSpace
             nameSpaces.reverse
-            prefix = Utils.join('.', for ns in nameSpaces get ns.name)
+            prefix = '.'.join( for ns in nameSpaces get ns.name)
             if prefix.length
                 prefix += '.'
             return prefix
@@ -533 +533 @@
     def _checkForInheritanceCycles(originalBox as Box, bases as Stack<of Box>)
         if this in bases
             names = for aBase in List<of Box>(Stack<of Box>(bases))[1:] get aBase.name
-            .throwError('Cyclical inheritance for "[.name]" with ancestor types [Utils.join(", ", names)] and back to [.name].')
+            .throwError('Cyclical inheritance for "[.name]" with ancestor types [", ".join(names)] and back to [.name].')
         else
             bases.push(this)
             if .baseClass, .baseClass._checkForInheritanceCycles(originalBox, bases)
@@ -861 +861 @@
             t = .memberwiseClone to Box
             assert t is not this
             genericDef._constructedTypes[key] = t
-            argNames = Utils.join(',', for type in typeArgs get type.name)
+            argNames = ','.join(for type in typeArgs get type.name)
             t._name = '[.rootName]<of [argNames]>'
             t._genericDef = this
             t._nativeType = nil  # The constructed type is really sourced from the generic def. Don't foster confusion with a reference to the original generic def's clr type (if there is one).

Source/Cobra.Lang/Extensions.cobra

@@ -27 +27 @@
             for i in chars.count, charsArray[i] = chars[i]
             return List<of String>(.split(charsArray))
 
+        # library String class join() only works on arrays of strings
+        def join(parts as System.Collections.IEnumerable) as String   # TODO: given that this seems necessary, should Cobra add "use System.Collections" to all programs?
+            """
+            Join the items in an IEnumerable collection separated by this string
+            """
+            test
+                assert '.'.join(['a', 'b'])=='a.b'
+                assert ' and '.join(['a', 'b'])=='a and b'
+            body
+                sep = this
+                sb = StringBuilder()
+                s = ''
+                for part in parts
+                    sb.append(s)
+                    sb.append(part.toString)
+                    s = sep
+                return sb.toString
+
+        def join(lastSep as String, parts as System.Collections.IEnumerable) as String
+            """
+            Join the items of an IEnumerable collection with this string except for the last 
+            two items; join them with the lastSep string
+            """
+            test
+                assert ', '.join(' and ', ['a', 'b'])=='a and b'
+                assert ', '.join(' and ', ['a', 'b', 'c'])=='a, b and c'
+                assert ', '.join(' and ', ['a', 'b', 'c', 'd'])=='a, b, c and d'
+            body
+                sep = this
+                sb = StringBuilder()
+                s = ''
+                partsList = []
+                for part in parts, partsList.add(part)
+                count = partsList.count
+                for i in count
+                    sb.append(s)
+                    sb.append(partsList[i].toString)
+                    s = if(i==count-2, lastSep, sep)
+                return sb.toString
+
+#       def join(sep as String, parts as vari String) as String  # CC: shouldn't need this because vari should implement IEnumerable
+#           return .join(sep, parts to System.Collections.IEnumerable)
+
+
+        def md5HashInHex as String
+            ensure
+                result.length == 32
+            test
+                assert 'Black holes and revelations.'.md5HashInHex == '95b141d670c19f2f20a820751897b9c6'
+            body
+                md5 = System.Security.Cryptography.MD5CryptoServiceProvider()
+                data = System.Text.Encoding.ascii.getBytes(this)  # why ASCII? why not utf8 or something?
+                data = md5.computeHash(data)
+                ret = ''
+                for i in data.length
+                    ret += data[i].toString('x2')
+                return ret
+
+        def countChars(c as char) as int
+            test
+                assert ''.countChars(c'x')==0
+                assert 'x'.countChars(c'x')==1
+                assert 'X'.countChars(c'x')==0  # case sensitive
+                assert ' ! ! '.countChars(c'!')==2
+            body
+                count = 0
+                for ch in this
+                    if c==ch
+                        count += 1
+                return count
+
+        def isCapped as bool
+            test
+                assert 'Aoeu'.isCapped
+                assert 'Zaoeu'.isCapped
+                assert not 'aoeu'.isCapped
+                assert not ''.isCapped
+                assert not '1234'.isCapped
+            body
+                return .length and this[0].isUpper
+
+        def capped as String
+            """
+            Returns the string with the first character capitalized.
+            Returns a blank string for a blank string.
+            """
+            ensure
+                result.length == .length
+                result.length implies result[0] == result[0].toUpper
+            test
+                assert 'chuck'.capped == 'Chuck'
+                assert 'Chuck'.capped == 'Chuck'
+                assert ''.capped == ''
+                assert ' foo'.capped == ' foo'
+                assert 'f'.capped == 'F'
+                assert '1aoeu'.capped == '1aoeu'
+            body
+                if .length == 0, return this
+                return this[0:1].toUpper + this[1:]
+            
+        def startsIsLower as bool
+            require
+                .length
+            test
+                assert 'a'.startsIsLower
+                assert 'z'.startsIsLower
+                assert not 'A'.startsIsLower
+                assert not '1'.startsIsLower
+                assert not '_'.startsIsLower
+            body
+                return this[0].isLower
+
+        def startsIsNonLower as bool
+            require
+                .length
+            test
+                assert not 'a'.startsIsNonLower
+                assert not 'z'.startsIsNonLower
+                assert not '1'.startsIsNonLower
+                assert 'A'.startsIsNonLower
+            body
+                return this[0] <> this[0].toLower
+                
+
     
     class DecimalTools
 

Source/CommandLine.cobra

@@ -446 +446 @@
     """
 
     get versionString as String is shared
-        ensure Utils.countChars(result, c'.') == 2
+        ensure result.countChars(c'.') == 2
 
         # Can't just take CobraCore.versionDescription as is, because that will be the one from Snapshot,
         # not the current Source directory. And Snapshot can be a final release such as '0.7.4' for a
@@ -858 +858 @@
         reMatch = Regex(r'\d+\.\d+\.\d+').match(.versionString)
         assert reMatch.success
         version = reMatch.value to !
-        assert Utils.countChars(version, c'.') == 2  # ex: '0.8.0'
+        assert version.countChars(c'.') == 2  # ex: '0.8.0'
         if ' ' in .versionString or 'post' in .versionString  # ex: '0.8.0 post'
             # 'post' versions have a fourth version component of 1, as opposed to 0
             version += '.1'
-            assert Utils.countChars(version, c'.') == 3
+            assert version.countChars(c'.') == 3
         _options.addExtraUse('use System.Reflection')
         _options.addExtraSource("assembly\n\thas AssemblyVersion('[version]')\n")
         .doCompile(List<of String>(), true, false, false)
@@ -988 +988 @@
                         errMsg = 'Cannot parse value "[valueStr]" for option "[name]".'
                         branch spec.type
                             on 'bool', errMsg += ' Possible values include yes, no, y, n, true, false, t, f, 1, 0, + and -.'
-                            on 'menu', errMsg += ' Possible values are [Utils.join(", ", " and ", spec.choices)].'
+                            on 'menu', errMsg += ' Possible values are [", ".join(" and ", spec.choices)].'
                         _error(errMsg)
                     valueDict[name] = value to !
                     didSpecify[name] = true
@@ -1007 +1007 @@
             # TODO: make the option names case-insensitive
 
             if mainOptions.count > 1
-                _error('Cannot have these main options at the same time: [Utils.join(", ", mainOptions)]')
+                _error('Cannot have these main options at the same time: [", ".join(mainOptions)]')
 
             _unpackOptions(valueDict, fileList) 
 
@@ -1082 +1082 @@
         """
         require name.trim <> ''
         ensure result.trim <> ''
-        name = Utils.getSS(_synToName to passthrough, name, name) to !
+        name = Utils.dictGetVOD<of String>(_synToName to passthrough, name, name)
         assert name.trim <> ''
         if not _specDict.containsKey(name)
             msg = 'No such option "[name]".'

Source/NameSpace.cobra

@@ -114 +114 @@
                     t.add(ns.name)
                     ns = ns._superNameSpace
                 t.reverse
-                _fullName = Utils.join('.', t)
+                _fullName = '.'.join(t)
             return _fullName to !
 
     def getOrMakeNameSpaceNamed(token as IToken, name as String) as NameSpace  # CC: same
@@ -195 +195 @@
         for ns in _subNameSpacesList, ns.bindInh
 
     def _checkCase
-        if Utils.startsWithLowerLetter(.name) and not .token.isEmpty
+        if .name.startsIsLower and not .token.isEmpty
             # TODO: make this an error eventually. warning added 2009-01-04
             .compiler.warning(this, 'Namespace names should start with an uppercase letter in order to avoid collisions with other identifiers such as arguments and local variables.')
 
@@ -212 +212 @@
                     for n in sameNames, remainingNames.remove(n)
                     # at this point we have, for example, ['Foo', 'foo', 'FOO']
                     
-                    namesMsgPart = Utils.join(' ', for n in sameNames get '"[n]"') + '.'
+                    namesMsgPart = ' '.join(for n in sameNames get '"[n]"') + '.'
                     if all for n in sameNames get _declsByName[n] inherits NameSpace
                         # namespaces can be spread across DLLs and source files in any combination, so they only get a warning
                         .compiler.warning(this, 'Multiple namespaces in "[.fullName]" differ only by case: ' + namesMsgPart)
@@ -289 +289 @@
                 membersList = List<of IMember>(members)
                 membersList.sort(do(a as IMember, b as IMember))
                     return a.parentNameSpace.fullName.compareTo(b.parentNameSpace.fullName)
-                spaces = Utils.join(', ', ' and ', for m in membersList get '"[m.parentNameSpace.fullName]"')
+                spaces = ', '.join(' and ', for m in membersList get '"[m.parentNameSpace.fullName]"')
                 if .compiler and .compiler.nodeStack.peek inherits ISyntaxNode
                     node = .compiler.nodeStack.peek
                 else
@@ -395 +395 @@
     cue init(token as IToken, nameParts as List<of String>, fileName as String?)
         base.init(token)
         _nameParts = nameParts
-        _fullName = Utils.join('.', nameParts)
+        _fullName = '.'.join(nameParts)
         _fileName = fileName ? ''
 
     def addMinFields

Source/Utils.cobra

@@ -8 +8 @@
 
 extend String
 
-    def capped as String
-        """
-        Returns the string with the first character capitalized.
-        Returns a blank string for a blank string.
-        """
-        ensure
-            result.length == .length
-            result.length implies result[0] == result[0].toUpper
-        test
-            assert 'chuck'.capped == 'Chuck'
-            assert 'Chuck'.capped == 'Chuck'
-            assert ''.capped == ''
-            assert ' foo'.capped == ' foo'
-            assert 'f'.capped == 'F'
-            assert '1aoeu'.capped == '1aoeu'
-        body
-            if .length == 0, return this
-            return this[0:1].toUpper + this[1:]
-
-    def md5HashInHex as String
-        ensure
-            result.length == 32
-        test
-            assert 'Black holes and revelations.'.md5HashInHex == '95b141d670c19f2f20a820751897b9c6'
-        body
-            md5 = System.Security.Cryptography.MD5CryptoServiceProvider()
-            data = System.Text.Encoding.ascii.getBytes(this)  # why ASCII? why not utf8 or something?
-            data = md5.computeHash(data)
-            ret = ''
-            for i in data.length
-                ret += data[i].toString('x2')
-            return ret
-
     ## Language specific
 
     def canBeUndottedMemberName as bool
@@ -52 +19 @@
         names are typically protected data fields or methods while the uppercase names would be
         enums or (in the future) nested boxes.
         """
-        return .startsWith('_') or Utils.isCapped(this)
+        return .startsWith('_') or .isCapped
 
 
 class Utils
 
     shared
 
-        def combinePaths(a as String, b as String) as String
-            """
-            Same as Path.combine() but leaves no '\.\' or '/./' in the result.
-            """
-            p = Path.combine(a, b)
-            good = Path.directorySeparatorChar.toString
-            bad = '[good].[good]'
-            p = p.replace(bad, good)
-            return p
-
-        def normalizePath(path as String) as String
-            while path.startsWith('.\\'), path = path[2:]
-            while path.startsWith('./'), path = path[2:]
-            return path
-
         def plural(items as System.Collections.ICollection) as String
             ensure
                 result == '' or result == 's'
@@ -88 +40 @@
             # Could be made more sophisitcated in the future
             return name + 's'
 
-        def isCapped(s as String) as bool
-            test
-                assert Utils.isCapped('Aoeu')
-                assert Utils.isCapped('Zaoeu')
-                assert not Utils.isCapped('aoeu')
-                assert not Utils.isCapped('')
-                assert not Utils.isCapped('1234')
-            body
-                return s.length and s[0].isUpper
-
-        def startsWithLowerLetter(s as String) as bool
-            require
-                s.length
-            test
-                assert Utils.startsWithLowerLetter('a')
-                assert Utils.startsWithLowerLetter('z')
-                assert not Utils.startsWithLowerLetter('A')
-                assert not Utils.startsWithLowerLetter('1')
-                assert not Utils.startsWithLowerLetter('_')
-            body
-                return s[0].isLower
-
-        def startsNonLower(s as String) as bool
-            require
-                s.length
-            test
-                assert not Utils.startsNonLower('a')
-                assert not Utils.startsNonLower('z')
-                assert not Utils.startsNonLower('1')
-                assert Utils.startsNonLower('A')
-            body
-                return s[0] <> s[0].toLower
-
         def toIdentifier(s as String) as String
             test
                 cases = [
@@ -140 +59 @@
                         sb.append(c'_')
                 return sb.toString
 
-        # TODO: count should be a CobraCore util method
-        # TODO: count should be an extension method of String
-        def countChars(s as String, c as char) as int
-            test
-                assert Utils.countChars('', c'x')==0
-                assert Utils.countChars('x', c'x')==1
-                assert Utils.countChars('X', c'x')==0  # case sensitive
-                assert Utils.countChars(' ! ! ', c'!')==2
-            body
-                count = 0
-                for ch in s
-                    if c==ch
-                        count += 1
-                return count
-
-        # CC: the getXX() methods should be one generic method
-
-        def getSB(d as Dictionary<of String, dynamic>, key as String, defaultValue as bool) as bool
+        # this should probably be an extension on Dictionary??
+        def dictGetVOD<of T>(d as Dictionary<of String, T>, key as String, defaultValue as T) as T
+            """
+            GetValueOrDefault genericised for return type.
+            Return the value for String key from Dictionary d or if none return provided 
+            default value
+            """
             if d.containsKey(key)
                 return d[key]
             else
                 return defaultValue
-
-        def getSI(d as Dictionary<of String, int>, key as String, defaultValue as int) as int
-            if d.containsKey(key)
-                return d[key]
-            else
-                return defaultValue
-
-        def getSS(d as Dictionary<of String, String?>, key as String, defaultValue as String?) as String?
-            if d.containsKey(key)
-                return d[key]
-            else
-                return defaultValue
-
-        def getSO(d as Dictionary<of String, Object>, key as String, defaultValue as Object?) as Object?
-            if d.containsKey(key)
-                return d[key]
-            else
-                return defaultValue
-
-        # CC: make join an extension method of String which already has a join() except that it only works on arrays of strings
-        def join(sep as String, parts as System.Collections.IEnumerable) as String  # TODO: given that this seems necessary, should Cobra add "use System.Collections" to all programs?
-            test
-                assert Utils.join('.', ['a', 'b'])=='a.b'
-            body
-                sb = StringBuilder()
-                s = ''
-                for part in parts
-                    sb.append(s)
-                    sb.append(part.toString)
-                    s = sep
-                return sb.toString
-
-        # CC: make join an extension method of String which already has a join() except that it only works on arrays of strings
-        def join(sep as String, lastSep as String, parts as System.Collections.IEnumerable) as String
-            test
-                assert Utils.join(', ', ' and ', ['a', 'b'])=='a and b'
-                assert Utils.join(', ', ' and ', ['a', 'b', 'c'])=='a, b and c'
-                assert Utils.join(', ', ' and ', ['a', 'b', 'c', 'd'])=='a, b, c and d'
-            body
-                sb = StringBuilder()
-                s = ''
-                partsList = []
-                for part in parts, partsList.add(part)
-                count = partsList.count
-                for i in count
-                    sb.append(s)
-                    sb.append(partsList[i].toString)
-                    s = if(i==count-2, lastSep, sep)
-                return sb.toString
-
-        def join(sep as String, parts as vari String) as String  # CC: shouldn't need this because vari should implement IEnumerable
-            return .join(sep, parts to System.Collections.IEnumerable)
-
-
+            
         ## C#
         
         def cobraNameForSharpMemberName(name as String) as String
@@ -291 +146 @@
                 print '[lineNum]|[line]'  # CC: right align and pad 0 the lineNum
                 lineNum += 1
 
-        def forceExtension(fileName as String, extension as String) as String
+        # These (next 3 methods) would be better as static extension methods on the Path class 
+        # but MS/C#/.Net doesnt support extending existing classes with *static* extension methods
+        # so they remain util methods albeit renamed.
+        def pathCombine(a as String, b as String) as String 
+            """
+            Same as Path.combine() but normalized such that it leaves no '\.\' or '/./' in the result.
+            """
+            p = Path.combine(a, b)
+            good = Path.directorySeparatorChar.toString
+            bad = '[good].[good]'
+            p = p.replace(bad, good)
+            return p
+
+        def pathNormalizeLeading( path as String) as String
+            """
+            Normalise this string as a path string removing any leading './' or '.\'
+            """
+            while path.startsWith('.\\'), path = path[2:]
+            while path.startsWith('./'), path = path[2:]
+            return path
+
+        def pathForceExtension(fileName as String, extension as String) as String
             require
                 fileName.length
                 extension.length
             ensure
                 result.endsWith(extension)
             test
-                assert Utils.forceExtension('foo.csv', '.exe') == 'foo.exe'
-                assert Utils.forceExtension('foo.csv', 'exe') == 'foo.exe'
-                assert Utils.forceExtension('foo', '.exe') == 'foo.exe'
-                assert Utils.forceExtension('foo', 'exe') == 'foo.exe'
-                assert Utils.forceExtension('foo.bar.csv', '.exe') == 'foo.bar.exe'
+                assert Utils.pathForceExtension('foo.csv', '.exe') == 'foo.exe'
+                assert Utils.pathForceExtension('foo.csv', 'exe') == 'foo.exe'
+                assert Utils.pathForceExtension('foo', '.exe') == 'foo.exe'
+                assert Utils.pathForceExtension('foo', 'exe') == 'foo.exe'
+                assert Utils.pathForceExtension('foo.bar.csv', '.exe') == 'foo.bar.exe'
             body
                 if not extension.startsWith('.')
                     extension = '.' + extension
@@ -323 +199 @@
             require path.length
             return .readKeyValues(path, File.openText(path), Console.out)
         
-        def readKeyValues(sr as StreamReader, warnings as TextWriter) as Dictionary<of String, String>
-            return .readKeyValues(sr, Console.out)
-
         def readKeyValues(path as String, tw as TextReader, warnings as TextWriter) as Dictionary<of String, String>
             test
                 nl = Environment.newLine

Source/CobraParser.cobra

@@ -242 +242 @@
                         textParts.add(tok.text)
                     else
                         .throwError('Expecting more doc string contents or the end of the doc string instead of [tok].')
-            text = Utils.join('', textParts)
+            text = ''.join(textParts)
             return text
         else if .optional('DOC_STRING_LINE')
             return .last.value to String
@@ -472 +472 @@
                     fileNameParts.add(id.text)
                     dot = .optional('DOT')
                     if not dot, break
-                fileName = Utils.join('.', fileNameParts)
+                fileName = '.'.join(fileNameParts)
             else
                 .throwError('Expecting a file name (sans extension, with or without quotes) after "from".')
             if fileName.endsWith('.dll') or fileName.endsWith('.exe')
@@ -780 +780 @@
                 if expectComma
                     .expect('COMMA')
                 ident = .expect('ID').text
-                if Utils.startsWithLowerLetter(ident)
+                if ident.startsIsLower
                     .throwError('Generic parameter names must start with an uppercase letter in order to avoid collisions with other identifiers such as arguments and local variables.')
                 params.add(GenericParam(ident))
                 expectComma = true
@@ -2595 +2595 @@
             else if peek=='NOT' and .peek(+1).which=='IN'
                 op = 'NOTIN'
             # handle precedence (and detect non-binary operators)
-            binaryOpPrec = Utils.getSI(_binaryOpPrec, op ? peek, -1)
+            binaryOpPrec = Utils.dictGetVOD<of int>(_binaryOpPrec, op ? peek, -1)
             if binaryOpPrec==-1 or binaryOpPrec<precedence
                 break
             # continue...
@@ -2878 +2878 @@
                 _spaceAgnostic
             if .peek is nil
                 literal = {'RPAREN': ')', 'RBRACKET': ']'}
-                what = Utils.join(" or ", for t in terminators get '"[if(literal.containsKey(t), literal[t], t)]"')
+                what = " or ".join(for t in terminators get '"[if(literal.containsKey(t), literal[t], t)]"')
                 .throwError('Expecting "," or [what].')
             if .peek.which in terminators
                 .grab
@@ -2975 +2975 @@
         if .opStack.count and .opStack.peek=='DOT'
             return MemberExpr(nameToken)
         if .peek.which=='AS'
-            if not Utils.startsWithLowerLetter(name)
+            if not name.startsIsLower
                 .throwError('Local variable declarations must start with a lowercase letter. This avoids collisions with other identifiers such as classes and enums.')
             return AsExpr(.grab, nameToken, .typeId)
         else
@@ -3017 +3017 @@
                             sep = which
                             break
                     if sep is nil
-                        .throwError('Expecting one of: [Utils.join(", ", separators)], but encountered [.peek.which]')
+                        .throwError('Expecting one of: [", ".join(separators)], but encountered [.peek.which]')
                 if sep=='COLON'
                     lastThingWasColon = true
             if .peek.which=='RBRACKET'
@@ -3157 +3157 @@
         nameToken = .expect('ID')
         name = nameToken.text
         if .peek.which=='AS'
-            if not Utils.startsWithLowerLetter(name)
+            if not name.startsIsLower
                 .throwError('Local variable declarations must start with a lowercase letter. This avoids collisions with other identifiers such as classes and enums.')
             return AsExpr(.grab, nameToken, .typeId)
         else
@@ -3372 +3372 @@
         other = box.declForNameCI(name)
         if other
             .throwError('There is already another class member with the name "[other.name]". You must differentiate member names by more than just case.')
-        if Utils.startsNonLower(name)
+        if name.startsIsNonLower
             .throwError('Property names must start with lowercase letters. ([name])')
 
     def checkStartsLowercase(identifier as String, whatName as String)
@@ -3392 +3392 @@
                 sugg = sugg[0].toString.toLower + sugg[1:]
                 sugg = ' Try "[sugg]".'
             .recordError('[whatName] declarations cannot start with an underscore. Those are reserved for class variables.[sugg]')
-        if Utils.startsNonLower(identifier)
+        if identifier.startsIsNonLower
             sugg = identifier[0].toString.toLower + identifier[1:]
             .recordError('[whatName] declarations must start with a lowercase letter to distinguish them from other types of identifiers. Try "[sugg]".')
 
@@ -3413 +3413 @@
         """
         token = .peek(peekAhead)
         if token.which == 'ID'
-            return Utils.startsNonLower(token.value to String)
+            return (token.value to String).startsIsNonLower
         return .isOneOfKeywords(token, ['bool', 'char', 'decimal', 'int', 'uint', 'float', 'number'])
 
     def looksLikeVarNameIsNext(peekAhead as int) as bool
         token = .peek(peekAhead)
-        return token is not nil and token.which=='ID' and Utils.startsWithLowerLetter(token.text)
+        return token is not nil and token.which=='ID' and token.text.startsIsLower
         
     def isOneOfKeywords(nToken as IToken?, keywords as List<of String>) as bool
         token = nToken to !

Source/TestifyRunner.cobra

@@ -195 +195 @@
                 paths.addRange(Directory.getDirectories('.') to passthrough)
                 paths.sort
                 for baseName in paths
-                    baseName = Utils.normalizePath(baseName)
+                    baseName = Utils.pathNormalizeLeading(baseName)
                     if baseName.startsWith('_'), continue
                     if baseName.endsWith('.cobra') or baseName.endsWith('.COBRA')
                         _testifyCount += .testifyFile(baseName)
@@ -245 +245 @@
         print
         print
         print 'RUN [baseName]'
-        print '    [Utils.combinePaths(Environment.currentDirectory, baseName)]'
+        print '    [Utils.pathCombine(Environment.currentDirectory, baseName)]'
         print '    Test #[_testifyCount+1]'
         print bar
         print bar
@@ -266 +266 @@
                 print 'Running multiple files.'
                 for fileName in firstLine.substring(firstLine.indexOf('.multi.')+8).split
                     if fileName.length
-                        fileNames.add(Utils.combinePaths(Path.getDirectoryName(baseName) to !, fileName))
-                print 'Multiple filenames:', Utils.join(', ', fileNames)
+                        fileNames.add(Utils.pathCombine(Path.getDirectoryName(baseName) to !, fileName))
+                print 'Multiple filenames:', ', '.join(fileNames)
                 # enable having another directive on the next line, such as .error.
                 lines = lines[1:]
                 firstLine = lines[0]

Developer/IntermediateReleaseNotes.text

@@ -34 +34 @@
 
 * Added extension methods to List<of T>. @@ expand on this
 
+* Moved useful Utils methods to extension methods.  ticket 111
+
 ================================================================================
 Command Line
 ================================================================================