Changeset 1746

Timestamp:

11/08/08 20:53:13 (2 months ago)

Author:

Chuck.Esterbrook

Message:

Added command line option -correct-case (or -cc) to change the case of types to the correct cases in situations that are not ambiguous.

Location:

cobra/trunk

Files:

• Developer/IntermediateReleaseNotes.text (modified) (1 diff)
• Source/CommandLine.cobra (modified) (1 diff)
• Source/Compiler.cobra (modified) (3 diffs)
• Source/TestifyRunner.cobra (modified) (1 diff)
• Source/TypeProxies.cobra (modified) (1 diff)
• Tests/700-command-line/850-correct-case.cobra (added)

cobra/trunk/Developer/IntermediateReleaseNotes.text

@@ -29 +29 @@
 
 Adding the extension (.exe or .dll) is neither required nor problematic.
+
+* Added command line option -correct-case (or -cc) to change the case of types to the correct cases in situations that are not ambiguous.
 
 * Modified commandline options so -r becomes synonym for -run rather  

cobra/trunk/Source/CommandLine.cobra

@@ -149 +149 @@
                         'args': 'none|inline|methods',
                         'default': 'inline',
+                },
+                {
+                        'name': 'correct-case',
+                        'synonyms': ['cc'],
+                        'description': 'Rewrite source files with case corrected where the correction is unambiguous. For example, "string" --> "String". If possible, you should set your editor to automatically reload files when using this option.',
+                        'type': 'bool',
                 },
                 {

cobra/trunk/Source/Compiler.cobra

@@ -285 +285 @@
                 if stopAfterBindInt, return  # in support of the -doc option
                 .bindImp
+                .writeSourceCodeCorrections
                 .writeSharp
                 if writeTestInvocation
@@ -1099 +1100 @@
 
         ##
+        ## Source Code Corrections
+        ##
+
+        var _sourceCorrections = Dictionary<of String, Dictionary<of int, List<of Replacement>>>()
+                """
+                The first key of type String is filename.
+                The second key of type int is line number.
+                """
+
+        def correctSource(token as IToken, replace as String)
+                if not _sourceCorrections.containsKey(token.fileName)
+                        _sourceCorrections[token.fileName] = Dictionary<of int, List<of Replacement>>()
+                file = _sourceCorrections[token.fileName]
+                if not file.containsKey(token.lineNum)
+                        file[token.lineNum] = List<of Replacement>()
+                file[token.lineNum].add(Replacement(token.colNum, token.text, replace))
+
+        def writeSourceCodeCorrections
+                # TODO: this doesn't properly handle when the replacements are a different length than the
+                # original next, but then this isn't needed right now since the only type of correction
+                # being done is case correction
+                v = .verbosity
+                for fileName, lineToReplacements in _sourceCorrections
+                        if v, print 'Correcting source:', fileName
+                        lineNums = List<of int>(lineToReplacements.keys)
+                        lineNums.sort
+                        lines = File.readAllLines(fileName)
+                        for lineNum in lineNums
+                                for rep in lineToReplacements[lineNum]
+                                        assert rep.oldText.length == rep.newText.length  # see TODO above
+                                        if v >= 2, print 'Correct: Line [lineNum], Column [rep.colNum], Old "[rep.oldText]", New "[rep.newText]"'
+                                        i = lineNum - 1
+                                        line = lines[i]
+                                        # print line
+                                        oldLen = line.length
+                                        col = rep.colNum - 1
+                                        lines[i] = line[:col] + rep.newText + line[col+rep.oldText.length:]
+                                        # print lines[i]
+                                        assert lines[i].length == oldLen
+                        try
+                                File.writeAllLines(fileName, lines)
+                        catch exc as Exception
+                                .warning(CobraWarning(fileName, nil, 'Cannot write source code corrections due to: [exc.message] ([exc.getType.name]).'))
+        
+        ##
         ## Important system library types
         ##
@@ -1529 +1575 @@
 
 
+class Replacement
+
+        def init(colNum as int, oldText as String, newText as String)
+                _colNum = colNum
+                _oldText = oldText
+                _newText = newText
+        
+        get colNum from var as int
+        
+        get oldText from var as String
+        
+        get newText from var as String
+
+
 class TestCompiler
         inherits Compiler

cobra/trunk/Source/TestifyRunner.cobra

@@ -197 +197 @@
                                 for baseName in paths
                                         baseName = Utils.normalizePath(baseName)
+                                        if baseName.startsWith('_'), continue
                                         if baseName.endsWith('.cobra') or baseName.endsWith('.COBRA')
                                                 _testifyCount += .testifyFile(baseName)

cobra/trunk/Source/TypeProxies.cobra

@@ -485 +485 @@
         def _resolveType as IType is override
                 # don't need to check "basic types" like int, bool, etc. here. the parser does those.
-                if Utils.isCapped(_name)
-                        symbol = .compiler.symbolForName(.name, true, false)  # nested enum and class types are capped and can be members of the current class
+                name = .name
+                if Utils.isCapped(name)
+                        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
-                        sugg = ''
-                        if not Utils.isCapped(_name)
-                                sugg = _name.capped
-                                other = .compiler.symbolForName(sugg, true, false)
-                                sugg = if(other, ' Try "[sugg]".', '')
-                        .throwError('Cannot find type for "[_name]".[sugg]')
+                        correctCase = .compiler.options.boolValue('correct-case')
+                        if correctCase
+                                if not Utils.isCapped(name)
+                                        # not very sophisticated, but catches 'string', 'object', etc.
+                                        name = name.capped
+                                        symbol = .compiler.symbolForName(name, true, false)
+                                        if symbol is not nil
+                                                .compiler.correctSource(.token, name)
+                        if symbol is nil
+                                sugg = ''
+                                if not Utils.isCapped(_name)
+                                        sugg = name.capped
+                                        other = .compiler.symbolForName(sugg, true, false)
+                                        sugg = if(other, ' Try "[sugg]". Also, consider the -correct-case option (see cobra -h for details).', '')
+                                .throwError('Cannot find type for "[_name]".[sugg]')
                 if symbol inherits ITypeProxy
                         return symbol.realType