Ticket #189: tkt-189-augment-and-cleanup.patch

Source/BackEndCommon/CurlyWriter.cobra

@@ -22 +22 @@
         if _initialBufferSize is nil
             s = Environment.getEnvironmentVariable('COBRA_INTERNAL_GENCODEINITIALBUFFERSIZE')
             if s is nil or s.trim == '', _initialBufferSize = 128 * 1024
-            else, _initialBufferSize = int.parse(s)
+            else, _initialBufferSize = int.parse(s to !)
         _sb = StringBuilder(_initialBufferSize to !)
         _cobraLineNum = _curlyLineNum = 1
         _curlyToCobraLineNum = {1 : 1}

Source/Expr.cobra

@@ -281 +281 @@
         """
         return ' whose type is "[.receiverType.name]"'
     
+    def _paramsCountMsg(defnName as String, params as IList<of Param>, args as IList<of Expr>) as String
+        item = if(defnName == r'[]', 'indexer', 'method')
+        countStr = if(args.count == 0, 'no arguments', '[args.count]') 
+        countStr += if(args.count == 1,  ' is', ' are') 
+        detail = _paramsVsArgsString(defnName, params, args)
+        priMsg =('The [item] "[defnName]" is expecting [params.count] argument[Utils.plural(params)], but [countStr] being supplied in this call. [detail]')
+        return priMsg
+            
+    def _paramsVsArgsString(defnName as String, params as IList<of Param>, args as IList<of Expr>) as String    
+        """ 
+        Generate a string augmenting error messages for calls with mismatched parameters and args.
+        List the declared arglist signature and calling Types.
+        """
+        item=''
+        if defnName == r'[]'
+            defnName = ''
+            item = 'indexer arglist '   
+        sb = StringBuilder('The [item]declaration is "[defnName](')
+        sep=''
+        for param in params
+            sb.append(sep)
+            sep=', '
+            sb.append('[param.name] as [param.type.name]')
+        sb.append(')"')
+        # TODO append definition return Type (if any)?
+        if args.count
+            sb.append(', the call is supplying an arglist of type[Utils.plural(args)] "(')
+            sep=''
+            for arg in args
+                sb.append(sep)
+                sep=', '
+                sb.append('[arg.type.name]')
+            sb.append(')".')
+        return sb.toString
+        
     def throwCannotFindMemberError(receiverExpr as Expr, memberName as String)
         __throwOrRecordCannotFindMemberError(receiverExpr, memberName, 1)
 
@@ -716 +751 @@
                             winner = definition.computeBestOverload(.args, .genericArgTypes, true)
                             sharp'definition = winner'
                             type = winner.resultType
-                            /#
-                            to-do: 2012-07-01 CE: the following just isn't ready
+                            /# #/
+                            #to-do: 2012-07-01 CE: the following just isn't ready
                             if winner inherits BoxMember # .no-warnings.
                                 if winner.name not in ['format', 'invoke', 'split', 'sort']  # to-do: hack
                                     params = winner.params
@@ -875 +910 @@
             if _name=='toString'  # to-do: hack: because many structs like Decimal have a toString() overload which cannot currently be expressed in SystemInterfaces.cobra
                 return false
             else
-                .throwError('The method "[definition.name]" is expecting [params.count] argument[Utils.plural(params)], but [args.count] are being supplied in this call.')
+                .throwError(_paramsCountMsg(definition.name, params, args)) #'The method "[definition.name]" is expecting [params.count] argument[Utils.plural(params)], but [countStr] being supplied in this call.'
         return true
-
+        
     def _inferOutArgs(args as IList<of Expr>, params as IList<of Param>, warn as bool) 
         for num, arg in args.numbered
             if _undefinedOutArg(arg)
@@ -925 +960 @@
                     print '<> param.type =', param.type
                     print '<> param.ifInheritsStack.count =', param.ifInheritsStack.count
                 if arg.type inherits NilableType and not param.type inherits NilableType and arg.type.nonNil.isAssignableTo(param.type)
-                    arg.recordError('Argument [i+1] of method "[_name]" expects a non-nilable type ([param.type.name]), but the call is supplying a nilable type ([arg.type.name]).')
+                    detail = _paramsVsArgsString(_name, params, args)
+                    arg.recordError('Argument [i+1] of method "[_name]" expects a non-nilable type ([param.type.name]), but the call is supplying a nilable type ([arg.type.name]). [detail]')
                 else
-                    arg.recordError('Argument [i+1] of method "[_name]" expects type [param.type.name], but the call is supplying type [arg.type.name].')
+                    detail = _paramsVsArgsString(_name, params, args)
+                    arg.recordError('Argument [i+1] of method "[_name]" expects type [param.type.name], but the call is supplying type [arg.type.name]. [detail]')
 
     def _toErrorPhrase(d as Direction) as String
         branch d
@@ -1502 +1539 @@
             return
             
         if not hasVari and args.count <> params.count
-            .throwError('The indexer is expecting [params.count] argument[Utils.plural(params)], but [args.count] are being supplied in this call.')
+            .throwError(_paramsCountMsg(r'[]', params, args))  # 'The indexer is expecting [params.count] argument[Utils.plural(params)], but [countStr] being supplied in this call.[msg]'
         for i in 0 : args.count
             arg = args[i]
             param = params[i]
@@ -1518 +1555 @@
                     print '<> param = ' stop
                     param.writeDeepString
                 if arg.type inherits NilableType and not param.type inherits NilableType and arg.type.nonNil.isAssignableTo(param.type)
-                    .throwError('Argument [i+1] of indexer expects a non-nilable type ([param.type.name]), but the call is supplying a nilable type ([arg.type.name]).')
+                    detail = _paramsVsArgsString(r'[]', params, args)
+                    .throwError('Argument [i+1] of indexer expects a non-nilable type ([param.type.name]), but the call is supplying a nilable type ([arg.type.name]). [detail]')
                 else
-                    .throwError('Argument [i+1] of indexer expects type [param.type.name], but the call is supplying type [arg.type.name].')
+                    detail = _paramsVsArgsString(r'[]', params, args)
+                    .throwError('Argument [i+1] of indexer expects type [param.type.name], but the call is supplying type [arg.type.name]. [detail]')
                         
     def toCobraSource as String is override
         sb = StringBuilder()
@@ -1718 +1757 @@
             else if defn inherits AbstractMethod
                 params = defn.params
                 if params.count <> 0 and not (params.count == 1 and params[0].type inherits VariType)
-                    .throwError('The method "[defn.name]" is expecting [params.count] argument[Utils.plural(params)], but no arguments are being supplied in this call.')
+                    .throwError(_paramsCountMsg(defn.name, params, List<of Expr>()))    # 'The method "[defn.name]" is expecting [params.count] argument[Utils.plural(params)], but no arguments are being supplied in this call.'
                 else if .name <> 'getType'  # ug, more special handling for getType
                     box = .binarySuperNode.left.type to? Box
                     if box

Source/Boxes.cobra

@@ -99 +99 @@
 
     def _allBaseTypes(memo as Set<of Box>) as Box*
         if .baseClass
-            if .baseClass not in memo
+            bc = .baseClass to !
+            if bc not in memo
                 memo.add(.baseClass to !)
                 yield .baseClass to !
             for bt in .baseClass.allBaseTypes

Source/SubversionUtils.cobra

@@ -50 +50 @@
                 re = Regex(r"/!svn/ver/(?'version'[0-9]*)/")
                 for match as Match in re.matches(fileText)
                     revInt, revText = 0, match.groups['version'].value
-                    if int.tryParse(revText, out revInt) and revInt > maxVer, maxVer = revInt
+                    if int.tryParse(revText to !, out revInt) and revInt > maxVer, maxVer = revInt
                 if maxVer > int.minValue, return maxVer
             return nil
 

Source/BackEndClr/ScanClrType.cobra

@@ -182 +182 @@
                 return Assembly.loadFrom(assemblyFileName)
 
     def _onReflectionOnlyAssemblyResolve(sender, args as ResolveEventArgs) as Assembly?
-        assName = args.name
+        assName = args.name to !
         rv = .referenceVerbosity - 1
         if rv < 0, rv = 0
         if assName in _didLoadAssemblies

Tests/820-errors/200-expressions/415-calls-wrong-indexer-detail.cobra

@@ +1 @@
+# wrong count and type calls on an indexer - chk detail info
+class X
+    
+    def main is shared
+        a = X()
+    
+        x = a['ss'] # .error. indexer arglist declaration
+        
+        x = a[1, 2]  # .error. arglist of types "(int, int)"
+        CobraCore.noOp(x)
+        
+        
+    get [i as int] as int
+        return 1    

Tests/820-errors/200-expressions/410-calls-wrong-method.cobra

@@ +1 @@
+# Calls with wrong counts and types
+class X
+    
+    def main is shared
+        a = X()
+        a.catCall(1, 'ss') # OK
+        a.catCall('ss')   # .error. expecting 2 arguments
+        a.catCall('ss', 1, 33.3, X()) # .error. expecting 2 arguments
+        a.mooseCall #.error. no arguments are being supplied
+        
+        a.duckCall(1) #.error. expects type String
+        a.duckCall(1, 'moooo') # .error. 2 are being supplied
+    
+        n as String? = 'xx'  
+        a.duckCall(n)   #.error. expects a non-nilable type (String)
+        a.noCall(1.1)  #.error. expects type String?
+        
+        
+    def catCall(a as int, s as String)
+        pass
+        
+    def duckCall(s as String)
+        pass
+        
+    def mooseCall(s as String)
+        pass
+    
+    def noCall(s as String?)
+        pass
+        
+    get [i as int] as int
+        return 1    

Tests/820-errors/200-expressions/412-calls-wrong-method-detail.cobra

@@ +1 @@
+# Calls with wrong counts/types - chk detail info
+class X
+    
+    def main is shared
+        a = X()
+        a.catCall(1, 'ss') # OK
+        a.catCall('ss')   # .error. supplying an arglist of type "(String)"
+        a.catCall('ss', 1, 33.3, X()) # .error. supplying an arglist of types
+        a.mooseCall #.error. mooseCall(s as String)
+        
+        a.duckCall(1) #.error. supplying an arglist of type "(int)"
+        a.duckCall(1, 'moooo') # .error. arglist of types "(int, String)"
+    
+        n as String? = 'xx'  
+        a.duckCall(n)   #.error. arglist of type "(String?)"
+        a.noCall(1.1)  #.error. declaration is "noCall(s as String?)"
+        
+        
+    def catCall(a as int, s as String)
+        pass
+        
+    def duckCall(s as String)
+        pass
+        
+    def mooseCall(s as String)
+        pass
+    
+    def noCall(s as String?)
+        pass
+        
+    get [i as int] as int
+        return 1