Ticket #37: noWarn.patch

Source/Tokenizer.cobra

@@ -300 +300 @@
     var _tokenDefs as List<of TokenDef>?
     var _tokenDefsByFirstChar as Dictionary<of char, List<of TokenDef>>?
     var _tokenDefsByWhich as Dictionary<of String, TokenDef>?
+    var _noWarnLines as ISet<of String>
     var _curTokenDef as TokenDef?
     var _lastTokenDef as TokenDef?
     var _avgCount = 0
@@ -314 +315 @@
     var _charNum as int
 
     def init
+        _noWarnLines = Set<of String>()
         _didReset = false
         _reset()
 
@@ -368 +370 @@
 
     get tokenDefsByWhich from var
     
+    get noWarnLines from var
 
     ## Other
 
@@ -436 +439 @@
         Returns all remaining tokens as a list.
         """
         tokens = List<of IToken>()
+        #st = DateTime.now
         while true
             t = .nextToken
             if t
                 tokens.add(t)
             else
                 break
+        # determine timings for various Tokeniser lexing changes
+        #duration = DateTime.now.subtract(st)
+        #if  tokens.count > 100 and duration > TimeSpan(0)
+        #   avt = (duration.ticks to int) / (tokens.count to int)
+        #   ms = avt/10000
+        #   fnm = _fileName
+        #   if _fileName.startsWith("(")
+        #       fnm = '(None)'
+        #   lastsl =_fileName.lastIndexOf("\\")
+        #   if lastsl > 0
+        #       fnm = _fileName[lastsl+1:] to !
+        #   print "[fnm.padRight(20)]\t[duration]\t[tokens.count]\t" stop
+        #   print " [ms:N3] ms/Token av ([ms/1000:N3]sec)"
         return tokens
 
     def restart
@@ -591 +608 @@
                     return nil
             try
                 assert _tokenDefs
-                if _narrowTokenDefs and _tokenDefs.count >= _minNumTokenDefsToNarrow
-                    assert _tokenDefsByFirstChar
-                    assert _sourceLine.length
-                    if _tokenDefsByFirstChar.containsKey(_sourceLine[0])
-                        # print 'Using short list for char: [_sourceLine[0]], [_sourceLine[0] to int]'
-                        tokenDefs = _tokenDefsByFirstChar[_sourceLine[0]]
-                    else
-                        tokenDefs = _tokenDefs to !
-                else
-                    tokenDefs = _tokenDefs to !
+                tokenDefs = _getCandidateTokenDefs(_sourceLine)
                 for tokenDef in tokenDefs
                     count += 1
-                    if tokenDef.ignoreCount
-                        tokenDef.ignoreCount -= 1
+                    if _skipMatchAttempt(tokenDef, _sourceLineIndex)
                         continue
-                    if not tokenDef.isActive
-                        continue
-                    if _sourceLineIndex>0 and tokenDef.requiresBOL
-                        continue
-                    if not .isActiveCall(tokenDef)
-                        continue
                     #print '<> Trying to match [tokenDef]'
                     sourceLine = _sourceLine to !
                     #print '_sourceLineIndex=[_sourceLineIndex]'
@@ -634 +635 @@
 
                     # enable methods to customize handling of tokens
                     reinvoke = false
-
-                    which = tok.which
-                    if _onTokenTypeCache.containsKey(which)
-                        meth = _onTokenTypeCache[which]
-                    else
-                        methName = 'On' + which
-                        meth = .getType.getMethod(methName)
-                        _onTokenTypeCache[which] = meth
-                        
+                    meth = _getTokenMethod(tok.which)
                     if meth
-                        try
-                            tok = meth.invoke(this, @[tok]) to IToken?
-                        catch tie as TargetInvocationException
-                            throw tie.innerException
-                        if tok is nil
-                            # skip token, so go to the next one
-                            reinvoke = true
-                        else
-                            # TODO: could probably make this more efficient by axing the queue and just checking for nextToken in this method
-                            while tok
-                                _tokenQueue.enqueue(tok)
-                                tok = tok.nextToken
-                            reinvoke = true  # to pick up the queue
+                        tok = _tokenPostProcess(meth, tok )
+                        # nil indicates skipped token - will re call this method
+                        if not tok 
+                            reinvoke = true  # to pick up next token after skipped
 
                     # finished with current line?
                     if _sourceLine.length==0
@@ -689 +673 @@
             _avgCount += count
             _avgCountNum += 1
 
+    def _getCandidateTokenDefs(sourceLine as String?) as List<of TokenDef>
+        if _narrowTokenDefs and _tokenDefs.count >= _minNumTokenDefsToNarrow
+            assert _tokenDefsByFirstChar
+            assert _sourceLine.length
+            if _tokenDefsByFirstChar.containsKey(_sourceLine[0])
+                # print 'Using short list for char: [_sourceLine[0]], [_sourceLine[0] to int]'
+                return _tokenDefsByFirstChar[_sourceLine[0]]
+        return _tokenDefs to !
+
+    def _skipMatchAttempt(tokenDef as TokenDef, sourceLineIndex as int) as bool
+        if tokenDef.ignoreCount
+            tokenDef.ignoreCount -= 1
+            return true
+        if not tokenDef.isActive
+            return true
+        if sourceLineIndex>0 and tokenDef.requiresBOL
+            return true
+        if not .isActiveCall(tokenDef)
+            return true
+        return false    
+
+    # get method for token (On<which>)  from cache if there else from reflection and cache it
+    def _getTokenMethod(which as String) as  MethodInfo? 
+        if not _onTokenTypeCache.containsKey(which) # not already in methods cache
+            methName = 'On' + which                 
+            meth = .getType.getMethod(methName)     
+            _onTokenTypeCache[which] = meth         
+        else
+            meth = _onTokenTypeCache[which]
+        return meth
+        
+    # invoke any tokenMethod and return adjusted token or first token in any returned
+    # token chain (rest of chain queued)
+    # nil token returned indicates token is skipped.
+    def _tokenPostProcess(meth as MethodInfo,  tok as IToken?) as IToken?
+        try
+            tok = meth.invoke(this, @[tok]) to IToken?
+        catch tie as TargetInvocationException
+            throw tie.innerException
+        if not tok
+            return nil  # token is to be skipped
+        retTok = tok
+        tok = tok.nextToken
+        while tok
+        # TODO: could probably make this more efficient by axing the queue and just checking for nextToken in this method
+            _tokenQueue.enqueue(tok)  # store any token chain returned by method call
+            tok = tok.nextToken
+        return retTok   
+
     def pushTokenDefs(defs as List<of TokenDef>)
         ensure
             _tokenDefs is defs
@@ -762 +795 @@
         # TODO: like parser, this should probably not be recorded unless it "makes it out". see comment in CobraParser.throwError
         throw .recordError(msg)
 
+    def addNoWarn(token as IToken)
+        entry='[token.fileName]:[token.lineNum]'
+        _noWarnLines.add(entry)
+        
     def checkTokens(tokens as List<of IToken>, expected as String)
         is shared
         """

Source/Compiler.cobra

@@ -74 +74 @@
     var _warnings as List<of SourceException>
     var _messages as List<of SourceException>  # all errors and warnings
     var _messagesPerSourceLine as IDictionary<of String, List<of SourceException>>  # key is 'filename:lineNum'
+    var _warningSuppressBySourceLine as ISet<of String>     # key is 'filename:lineNum'
 
     var _intermediateFileNames as List<of String>
     var _baseExeFileName as String = ''
@@ -104 +105 @@
         _codeMemberStack = Stack<of AbstractMethod>()
         _messages = List<of SourceException>()
         _messagesPerSourceLine = Dictionary<of String, List<of SourceException>>()
+        _warningSuppressBySourceLine = Set<of String>()
         _errors = List<of SourceException>()
         _warnings = List<of SourceException>()
         _intermediateFileNames = List<of String>()
@@ -181 +183 @@
     get warnings from var
 
     get messages from var
+    
+    set warningSuppressLines as ISet<of String>
+        _warningSuppressBySourceLine = value
 
     pro htmlWriter from var
         """
@@ -1153 +1158 @@
 
     def warning(cw as CobraWarning)
         require not cw.isError
+        if _suppressWarning(cw), return
         _addMessage(cw)
-        
+    
+    def _suppressWarning(cw as CobraWarning) as bool
+        # TODO: add suppress all warnings (cmdline sw) - maybe?
+        # TODO: add suppress by error tag - maybe?
+        entry = if(cw.hasSourceSite, '[cw.fileName]:[cw.lineNum]', '')
+        return _warningSuppressBySourceLine.contains(entry)
+            
     def augmentWarning(node as ISyntaxNode, lookFor as String, search as String, augment as String) as bool
         require 
             lookFor.length

Source/CobraParser.cobra

@@ -219 +219 @@
                 msg = 'Token error: ' + msg
             .throwError(te.token, msg)
 
+        #TODO: fold all occcurrences of this lookup to a helper
+        compiler = .typeProvider to? Compiler
+        if compiler, compiler.warningSuppressLines = tokenizer.noWarnLines
+
         if tokenizer.errors.count
             for error in tokenizer.errors
                 .recordError(error.token, error.message)
-            
+
         _nextTokenIndex = 0
 
 
@@ -548 +552 @@
                 if typeName.text not in ['decimal', 'float', 'float32', 'float64']
                     .throwError('Compiler directive "number": unrecognized type "[typeName.text]". Must be one of "decimal", "float", "float32" or "float64".')
                 .expect('EOL')
-                comp = .typeProvider to Compiler?
+                comp = .typeProvider to? Compiler
                 if comp, comp.numberTypeName = typeName.text
             else
                 .throwError('Unknown compiler directive.')

Source/CobraTokenizer.cobra

@@ -389 +389 @@
     def onWHITESPACE_COMMENT_2(tok as IToken) as IToken?
         #print '<> onWHITESPACE_COMMENT_2'
         return nil
-
+    
     ##
     ## Comment out block
     ##
@@ -506 +506 @@
 
     def onSINGLE_LINE_COMMENT(tok as IToken) as IToken?
         # eat these
+        .chkForLeadingCommentToken(tok)
         return nil
 
+    def chkForLeadingCommentToken(tok as IToken)
+        insens = tok.text.trimStart.toLower
+        # nowarn is only one to date
+        if insens.startsWith('#.nowarn.') or insens.startsWith('#.no-warn.')
+            .addNoWarn(tok)
+            
     def onSPACE(tok as IToken) as IToken?
         # eat these
         return nil

Tests/800-warnings/400-no-warn.cobra

@@ +1 @@
+# test use of various forms of .noWarn comment token to suppress warnings
+# probably should stick to either   #.nowarn.  #.noWarn. or #.no-warn.
+class E
+    var _count =0   
+    var rCount =0
+    
+    sig BumpEventHandler(sender as Object, args as EventArgs) 
+    event bumpEvent as BumpEventHandler 
+
+
+    # (protected) method to raise/fire the event for this class
+    def _onBumpEvent(args as EventArgs)
+        raise .bumpEvent, this, args    #.noWarn. warning:implied this
+        
+    def bump
+        _count += 1 
+        if _count % 10 == 0
+            ev = EventArgs()
+            _onBumpEvent(ev)    
+            assert this.rCount  #.NoWarn. warning:unnecessary this literal  
+            
+            
+    def doBump(source as Object, eArgs as EventArgs)
+        .rCount += 1
+
+#class Driver       
+    def main is shared, shared #.No-WARN. warning:duplicate modifier
+        e = E()
+        listen e.bumpEvent, ref e.doBump
+        for i in 20
+            e.bump
+        assert e.rCount == 2
+
+        j=99        #.no-warn.  warning: never used
+        a = 99
+        if (a < 10) #.noWarn.  warning: Unnecessary parens
+            a=10
+        assert a is 99      #.NoWaRn.  warning:value Types  
+        assert a is not 100 #.nOwArN.  warning:value Types  
+
+        s='string'
+        t = s to String     #.no-Warn. warning:redundant typecast
+        t1 = s to String?   #.NOWARN.  warning:just use to ?

Developer/IntermediateReleaseNotes.text

@@ -1 +1 @@
 Post 0.8
 
+* Add support for warning suppression on arbitrary lines by placing a trailing
+    comment containing .nowarn. or .no-warn. immediately after the #
+    e.g.   this.call()  #.nowarn. 
+
 * Add support for commenting full blocks of lines using /# and #/. Block comments can be nested.
     '/#' block comment start and  '#/' block comment end as initial chars on line