Ticket #151: vari-typed-params.patch

Source/Expr.cobra

@@ -727 +727 @@
                             #/
                         else
                             type = definition.resultType
-                            if not _didVariArgs(definition)
+                            if _didVariArgs(definition)
+                                params = definition.params
+                                _checkArgsAssignable(definition, args, params)
+                            else
                                 definition = _checkGenerics(definition, inout type)
                                 if not definition.hasParams
                                     _checkNoArgs(definition, args)
@@ -736 +739 @@
                                     if _checkParamsCount(definition, args, params)
                                         if needInferOutArgs, _inferOutArgs(args, params, false) 
                                         _checkArgsAssignable(definition, args, params)
+                                
                         _checkInOutArguments
                         _checkVisibility(definition, dotNode.left)
                 else
@@ -896 +900 @@
         for i in args.count
             arg = args[i]
             param = params[i]
-            if param.type inherits VariType, break  # to-do: vari args not checked yet
-            if arg.hasError
+            if arg.hasError 
                 break
             if arg inherits AssignExpr  # assignments in arguments have special treatment
                 break
+            if param.type inherits VariType 
+                _checkVariArgsAssignable(args, params, i, arg, param)
+                break   
             assert arg.didBindImp
             assert param.didBindInt
             # check any in/out/inout expectations are matched
@@ -929 +935 @@
                 else
                     arg.recordError('Argument [i+1] of method "[_name]" expects type [param.type.name], but the call is supplying type [arg.type.name].')
 
+    def _checkVariArgsAssignable(args as IList<of Expr>, params as IList<of Param>, ofset as int, arg as Expr, param as Param)
+        require param.type inherits VariType 
+        variType = param.type.innerType to !
+        typeName = param.type.name
+        if typeName.startsWith('vari Object') or typeName.startsWith('vari dynamic')  # always assignable
+            return
+        argPos = ofset+1
+        if args.count == argPos and arg.canBeAssignedTo(variType) #single arg for last vari param
+            return
+        if variType inherits ArrayType  # library variType is Array
+            variArrayType = variType.innerType to !
+            if arg.canBeAssignedTo(variArrayType)
+                return
+        if arg.canBeAssignedTo(param.type) # variType and array
+            arg.contextType = param.type
+            return
+        if args.count <> params.count # variType and arg list
+            t = arg.type
+            for i in ofset+1 : args.count
+                t = t.greatestCommonDenominatorWith(args[i].type to !)
+            if t.isAssignableTo(variType)
+                return
+            arg.recordError(_variArgsErrorMsg(t to !,  param.type, argPos, true))       
+            return
+        arg.recordError(_variArgsErrorMsg(arg.type to !, param.type, argPos, false))        
+                    
+    def _variArgsErrorMsg(argType as IType, paramType as IType, argPos as int, withArgList as bool) as String       
+        targetMsg = if(withArgList, ' an arglist resolving to', '')
+        if argType inherits NilableType and not paramType inherits NilableType
+            msg = 'Vari argument [argPos] of method "[_name]" expects a non-nilable type ([paramType.name]), but the call is supplying[targetMsg] a nilable type ([argType.name]).'
+        else
+            msg = 'Vari argument [argPos] of method "[_name]" expects type [paramType.name], but the call is supplying [targetMsg] type [argType.name].'
+        return msg
+        
     def _toErrorPhrase(d as Direction) as String
         branch d
             on Direction.In, return 'a regular'

Source/CommandLine.cobra

@@ -575 +575 @@
         return ver
 
     get opSysString as String is shared
-        # to-do: after next compiler snapshot, replace this with CobraCore.operatingSystemDescription
-        name = ''
-        if File.exists('/System/Library/CoreServices/SystemVersion.plist')
-            # Mac
-            content = File.readAllText('/System/Library/CoreServices/SystemVersion.plist')
-            match = Regex.match(content, r'<string>(Mac[^<]+)')
-            if match.success
-                name += match.groups[1].toString
-            match = Regex.match(content, r'<string>(\d+\.[\d\.]+)')
-            if match.success
-                name += ' ' + match.groups[1].toString
-        else if File.exists('/etc/lsb-release')
-            # Ubuntu, ...
-            content = File.readAllText('/etc/lsb-release')
-            d = Dictionary<of String, String>()
-            for line in content.splitLines
-                line = line.trim
-                if line == '' or line.startsWith('#') or '=' not in line, continue
-                pair = line.split('=', 2)
-                d[pair[0].trim] = pair[1].trim
-            if d.containsKey('DISTRIB_DESCRIPTION'), name = d['DISTRIB_DESCRIPTION'].trim
-            if name == ''
-                try
-                    name = d['DISTRIB_ID'] + ' ' + d['DISTRIB_RELEASE']
-                catch
-                    pass
-            if name.startsWith('"') and name.endsWith('"'), name = name[1:-1]
-        else if File.exists('/etc/arch-release')
-            # Arch Linux
-            name = 'Arch Linux ' + _getCommandOutput('/bin/uname', '-r').trim
-            pacman = _getCommandOutput('pacman', '--version')
-            match = Regex.match(pacman, r'[Pp]acman v?(\d+\.[\d\.]+)')
-            if match.success
-                name += ' (pacman ' + match.groups[1].toString.trim + ')'
-        else if File.exists('/etc/system-release')
-            # CentOS, Fedora, ...
-            name = File.readAllText('/etc/system-release')
-        else if File.exists('/etc/redhat-release')
-            # RedHat, ...
-            name = File.readAllText('/etc/redhat-release')
-        name = name.trim
-        if name == ''
-            # everyone else
-            name = Environment.osVersion.toString
-        return name
+        return CobraCore.operatingSystemDescription
 
     def _getCommandOutput(command as String, args as String) as String is shared
         p = System.Diagnostics.Process()

Tests/800-warnings/600-vari-nilable-pars.cobra

@@ +1 @@
+class Test
+
+    def takesVari(x as vari String) is shared
+        for y in x
+            print y
+
+    def takesVariNil(x as vari String?) is shared
+        for y in x
+            print y
+
+    def takesArray(x as String[]) is shared
+        for y in x
+            print y
+        
+    def foo(args as vari int) as int is shared
+        sum = 0
+        for arg in args, sum += arg
+        return sum
+        
+    def main is shared
+        
+        .takesVari('hola', nil)     # .error. expects a non-nilable 
+        .takesVari(@['hola', nil])  # .error. expects type vari String
+
+        #.takesArray(@['hola', nil])  #Argument 1 expects type String[], but supplying type String?[]
+        
+        .takesVari('hola', 'nonnil')
+        .takesVariNil('hola', nil)
+        
+        x = .foo(1,2)
+        assert x == 3
+        x = .foo(1)
+        assert x == 1