Ticket #325: optional-params.patch

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
+    def _paramsCountMsg(defnName as String, params as IList<of Param>, nOptParams as int, 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)
-        msg = 'The [item] "[defnName]" is expecting [params.count] argument[Utils.plural(params)], but [countStr] being supplied in this call. [detail]'
+        optPart = if(nOptParams, ' ([nOptParams] optional)','')
+        expectingPart = 'is expecting [params.count] argument[Utils.plural(params)][optPart]'
+        suppliedPart = 'but [countStr] being supplied in this call'
+        msg = 'The [item] "[defnName]" [expectingPart], [suppliedPart]. [detail]'
         return msg
 
     def _paramsVsArgsString(defnName as String, params as IList<of Param>, args as IList<of Expr>) as String    
@@ -301 +304 @@
         sb = StringBuilder('The [item]declaration is "[defnName](')
         sep = ''
         for param in params
-            sb.append('[sep][param.name] as [param.type.name]')
+            optInit = if(param.optValue, ' = [param.optValue.toCobraSource]', '')
+            sb.append('[sep][param.name] as [param.type.name][optInit]')
             sep = ', '
         sb.append(')"')
         # to-do: append definition return Type (if any)?
@@ -910 +914 @@
             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(_paramsCountMsg(definition.name, params, args)) #'The method "[definition.name]" is expecting [params.count] argument[Utils.plural(params)], but [countStr] being supplied in this call.'
+                haveErr = args.count > params.count 
+                if not haveErr
+                    nOptionalParams =0
+                    for p in params, if p.optValue, nOptionalParams += 1
+                    #print '[params.count] Params [nOptParams] Optional'    
+                    haveErr = args.count < params.count - nOptionalParams
+                if haveErr
+                    .throwError(_paramsCountMsg(definition.name, params, nOptionalParams, 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) 
@@ -1579 +1590 @@
             return
             
         if not hasVari and args.count <> params.count
-            .throwError(_paramsCountMsg(r'[]', params, args))  # 'The indexer is expecting [params.count] argument[Utils.plural(params)], but [countStr] being supplied in this call.[msg]'
+            .throwError(_paramsCountMsg(r'[]', params, 0, 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]
@@ -1796 +1807 @@
                     .throwError('Could not find an overload for "[.name]" with zero arguments.')
             else if defn inherits AbstractMethod
                 params = defn.params
-                if params.count <> 0 and not (params.count == 1 and params[0].type inherits VariType)
-                    .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.'
+                nOptionalParams =0  
+                if params.count <> 0 and not _allParamsOptional(params, out nOptionalParams)
+                    .throwError(_paramsCountMsg(defn.name, params, nOptionalParams, 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
@@ -1814 +1826 @@
                                     _type = mbr.resultType
                                     break
 
+    def _allParamsOptional(params as IList<of Param>, nOptParams as out int) as bool
+        """VariArg single param  or all params in paramList optional."""
+        nOptParams=0
+        if params.count == 1 and params[0].type inherits VariType
+            return true
+        for p in params, if  p.optValue,  nOptParams += 1
+        return  nOptParams == params.count
+        #return false
+        
     def toCobraSource as String is override
         return _name
     

Source/BackEndClr/SharpGenerator.cobra

@@ -544 +544 @@
         d = writer.curlyToCobraLineNum
 
         # Output
+        #print 'Output: ', writer.output
         (.compiler to Compiler).createSharpFile(.sharpFileName, writer.output)
 
         return d
@@ -1489 +1490 @@
             on Direction.InOut, sw.write('ref ')
             on Direction.Out, sw.write('out ')
         sw.write('[.type.sharpParamRef] [.sharpName]')
-
+        if .optValue    # Net4 optional param
+            sw.write('=')
+            _optValue.writeSharpDef(sw)
+            
     def writeSharpDefSansReferenceLabels(sw as CurlyWriter)
         """
         Writes the parameter declaration but without C# "out" or "ref"--these are not available for

Source/CobraParser.cobra

@@ -1853 +1853 @@
             foo as List<of int>
             foo   # default type (dynamic?)
             foo as Type has Attribute(arg1, arg2)
+            foo [as Type] = optionalValue [has Attribute]
             foo has Attribute(arg1, arg2)
         """
         if .peek.which == 'OPEN_GENERIC'
@@ -1900 +1901 @@
         else
             type = TypeProxy(_typeProvider.defaultType)
             isMissingType = true
+                
+        if .optional('ASSIGN')  # default value for optional param
+            optExpr = .expression to ? # a constant, value Type or default(Type)
+        else
+            optExpr = nil
+            if type is nil
+                type = .typeProvider.defaultType
+            
         attribs = AttributeList()
         if .optional('HAS')
             # TODO: multiple attribs like: x as Type has (Attrib1, Attrib2)
             attribs.add(AttributeDecl(.attribExpr(0)))
         # note: isMissingType is currently used to generate a warning in .paramDecls above
         # and may be used for anonymous method parameter type inference at some point
-        return Param(token, type, isMissingType=isMissingType, direction=dir, isDeclaredAsUnused=declaredAsUnused, attributes=attribs)
+        return Param(token, type, isMissingType=isMissingType, direction=dir, 
+            isDeclaredAsUnused=declaredAsUnused, optValue=optExpr, attributes=attribs)
 
 
     ##

Source/Vars.cobra

@@ -172 +172 @@
 
 
 class Param inherits AbstractLocalVar is partial
-
+    
+    var _optValue as Expr? 
+        """Default value for an optional parameter."""
+    
     cue init(token as IToken, type as IType)
         base.init(token, type)
 
@@ -207 +210 @@
 
     pro direction from var as Direction
 
+    pro optValue from var 
+        """ Value for optional param. Marks param as optional"""
+    
     get isInOut as bool
         return .direction == Direction.InOut
 
@@ -239 +245 @@
 
     def _bindInt
         base._bindInt
+        if _optValue
+            # TODO: check optValue is constant, valueType ctor or 'default(valueType')
+            #print _optValue
+            _optValue.bindImp  # that's bindImp intentionally
+            #print _optValue.type
+            if not _optValue.canBeAssignedTo(_type to !)
+                .throwError('Incompatible types. Cannot assign value of type [_optValue.type.name] on the right to [_type.name] on the left.')
         for attrib in .attributes
             try
                 attrib.bindInt
@@ -247 +260 @@
 
     def _bindImp
         base._bindImp
+        if  .isMissingType and _optValue and _optValue.type and not _optValue inherits NilLiteral
+            #infer param type from optional param default value
+            #if NilLiteral just leave it alone
+            _type = _optValue.type
         for attrib in .attributes
             try
                 attrib.bindImp

Source/BackEndJvm/JavaGenerator.cobra

@@ -1309 +1318 @@
         base.writeJavaDef(sw)
         # TODO
         #if .type.isReference and not .type inherits NilableType
-        #   sw.write(r'[Cobra.Core.NotNull] ') 
+        #   sw.write(r'[Cobra.Core.NotNull] ') # TODO: annotations on params avail in Java8
         branch .direction
             on Direction.In, pass
             on Direction.InOut, sw.write('/*inOut*/')   # default
             on Direction.Out, sw.write('/*out*/')       # TODO
         sw.write('[.type.javaParamRef] [.javaName]')
+        if .optValue    # Net4 optional param
+            detail='For java at the moment you will need to recode the optional parameter method as a set of overloaded (possibly cascaded) methods with the desired number of parameters.'
+            .compiler.warning(this, 'Java does not support optional parameters. Default parameter value setting is ignored. [detail]')
+            #sw.write('=')
+            #_optValue.writeSharpDef(sw)
 
     def writeJavaDefSansReferenceLabels(sw as CurlyWriter)
         """
         Writes the parameter declaration but without Java "out" or "ref"--these are not available for
         contract methods (require_foo and ensure_foo) because contracts cannot modify arguments.
         """
-        # skip the [NotNull] as well since it's not really needed
         sw.write('[.type.javaRef] [.javaName]')     
 
 

Tests/160-methods/630-opt-param-string.cobra

@@ +1 @@
+# String default
+class OptParam
+    def main is shared
+        x = OptParam()
+        x.val = 'none'
+        x.foo('default')
+        assert x.val == 'defaultVal'
+        x.foo('provided', 'xyzzy')
+        assert x.val == 'xyzzy'
+
+    var val = ''
+    
+    def foo(f as String, s = 'defaultVal') 
+        if f == 'default'
+            assert s == 'defaultVal'
+        .val = s

Tests/160-methods/600-opt-param-inferred-type.cobra

@@ +1 @@
+# single optional param
+class OptParam
+    def main is shared
+        x = OptParam()
+        x.call = 0
+        x.foo('default')
+        assert x.call ==1
+        x.foo('provided',10)
+        assert x.call == 10
+
+    var call =0
+    
+    def foo(s as String, i = nil) # optional single (dynamic) param
+        #print s,i
+        if s == 'default'
+            assert i == nil
+            i = 1
+        .call = i

Tests/160-methods/620-opt-param-bool.cobra

@@ +1 @@
+# boolean default
+class OptParam
+    def main is shared
+        x = OptParam()
+        x.val = true
+        x.foo('default')
+        assert x.val == false
+        x.foo('provided', true)
+        assert x.val
+
+    var val = false
+    
+    def foo(s as String, b = false) 
+        if s == 'default'
+            assert b == false
+        .val = b

Tests/160-methods/610-opt-param-inferred-type.cobra

@@ +1 @@
+# single optional param
+class OptParam
+    def main is shared
+        x = OptParam()
+        x.call = 0
+        x.foo('default')
+        assert x.call ==1
+        x.foo('provided',10)
+        assert x.call == 10
+
+    var call = 0
+    
+    def foo(s as String, i = 1) # optional single param
+        #print s,i
+        if s == 'default'
+            assert i ==1
+        .call = i

Tests/160-methods/640-opt-param-list.cobra

@@ +1 @@
+# single optional param
+class OptParam
+    
+    def main is shared
+        x = OptParam()
+        x.call = [0]
+        x.foo('default')
+        assert x.call == nil
+        x.foo('provided',[1,4,9])
+        assert x.call == [1,4,9]
+
+    var call as List<of int>? =[0]  
+    def foo(s as String, l as List<of int>? = nil) 
+        #print s,i
+        .call = l

Tests/160-methods/641-opt-param-list.cobra

@@ +1 @@
+# single optional param
+class OptParam
+    
+    def main is shared
+        x = OptParam()
+        x.call = [0]
+        x.foo('default')
+        assert x.call == nil
+        x.foo('provided',[1,4,9])
+        assert x.call == [1,4,9]
+
+    var call as List<of int>? =[0]  
+    def foo(s as String, l as List<of int>? = nil) 
+        #print s,i
+        .call = l

Tests/160-methods/400-optional-ctor-arg.cobra

@@ +1 @@
+class OptCtor
+    def main is shared
+        x = OptCtor()
+        assert x.x == 'default'
+
+        x1 = OptCtor('foo')
+        assert x1.x == 'foo'
+
+    var x = ''
+    
+    cue init(s as String = 'default')   
+        base.init
+        .x = s
+        print 'OptCtor [.x]'
+        

Tests/160-methods/800-no-args-error.cobra

@@ +1 @@
+# count of optparams in error message
+class OptionalExample
+    def main is shared
+        eg = EClass()
+        eg.twoOpt() #.error. expecting 3 arguments (2 optional)
+        
+class EClass
+    var name as String
+    
+    cue init(name as String)
+        base.init
+        .name = name
+
+    def twoOpt(required as int, optionalstr as String = "default",  optionalint as int = 10)
+        pass

Tests/160-methods/100-optional-params.cobra

@@ +1 @@
+# fixed and single optional param
+class OptParam
+    def main is shared
+        x = OptParam()
+        x.call = 0
+        x.foo('default')
+        assert x.call ==1
+        x.foo('provided',10)
+        assert x.call == 10
+
+    var call = 0
+    
+    def foo(s as String, i as int = 1) # optional single param
+        #print s,i
+        if s == 'default'
+            assert i ==1
+        .call = i

Tests/160-methods/641-opt-param-list.cobra#

@@ +1 @@
+# Cannot pass non compile const as default values
+class OptParam
+    
+    def main is shared
+        x = OptParam()
+        x.call = [0]
+        x.foo('default')
+        assert x.call == [1,2,3]
+        x.foo('provided',[1,4,9,16 ])
+        assert x.call == [1,4,9,16]
+
+    var call = List<of int>()
+    
+    def foo(s as String, l as List<of int>? = nil) 
+        #print s,i
+        if not l
+            l = [1,2,3]
+        .call = l

Tests/160-methods/200-optional-params.cobra

@@ +1 @@
+class OptParam
+    def main is shared
+        x = OptParam()
+        x.call = 0
+        x.foo
+        assert x.call ==1
+        x.foo(10)
+        assert x.call == 10
+
+    var call = 0
+    
+    def foo(i as int = 1) # optional single param
+        print i
+        .call = i

Tests/160-methods/300-optional-params.cobra

@@ +1 @@
+class OptParam
+    def main is shared
+        x = OptParam()
+        assert x.val ==0 and x.isOn == false
+        x.isOn = true
+        x.foo('this')
+        assert x.val ==1 and x.isOn == false
+        x.isOn = true
+        x.foo('is', 10)
+        assert x.val == 10 and x.isOn == false
+        x.foo('sparta', 20, true)
+        assert x.val == 20 and x.isOn == true
+
+    var val = 0
+    var isOn = false
+    
+    def foo(s as String, i as int = 1, isOn as bool = false)
+        .val = i
+        .isOn = isOn

Tests/160-methods/700-optional.cobra

@@ +1 @@
+class OptionalExample
+    def main is shared
+        # Instance eg does not send an argument for the constructor's 
+        # optional parameter.
+        eg = ExampleClass()
+        assert eg.name =='Default name'
+        eg.exampleMethod(1, "One", 1)
+        assert eg.required ==1 and eg.optionalStr == 'One' and eg.optionalInt ==1
+        eg.exampleMethod(2, "Two")
+        assert eg.required ==2 and eg.optionalStr == 'Two' and eg.optionalInt ==10
+        eg.exampleMethod(3)
+        assert eg.required ==3 and eg.optionalStr == 'default' and eg.optionalInt ==10
+
+        # Instance eg2 sends an argument for the constructor's  optional parameter.
+        eg2 = ExampleClass("Provided name")
+        assert eg2.name =='Provided name'
+        eg2.exampleMethod(1, "One", 1)
+        assert eg2.required ==1 and eg2.optionalStr == 'One' and eg2.optionalInt ==1
+        eg2.exampleMethod(2, "Two")
+        assert eg2.required ==2 and eg2.optionalStr == 'Two' and eg2.optionalInt ==10
+        eg2.exampleMethod(3)
+        assert eg2.required ==3 and eg2.optionalStr == 'default' and eg2.optionalInt ==10
+
+        # The following statements produce compiler errors. 
+        # An argument must be supplied for the first parameter, and it 
+        # must be an integer. 
+        #eg.exampleMethod("One", 1)
+        #eg.exampleMethod() 
+
+        # You cannot leave a gap in the provided arguments.  
+        #eg.exampleMethod(3, ,4) 
+        #eg.exampleMethod(3, 4) 
+
+        # You can use a named parameter to make the previous  
+        # statement work.
+        #eg.exampleMethod(3, optionalint: 4)
+        
+class ExampleClass
+    var name as String
+    
+    var required =0
+    var optionalStr = ''
+    var optionalInt =0
+    
+    cue init(name as String = "Default name")
+        base.init
+        .name = name
+
+    # The first parameter, required, has no default value assigned 
+    # to it. Therefore, it is not optional. Both optionalstr and  
+    # optionalint have default values assigned to them. They are optional. 
+    def exampleMethod(required as int, optionalstr as String = "default",  optionalint as int = 10)
+        #print String.format("{0}: {1}, {2}, and {3}.", .name, required,    optionalstr, optionalint)
+        .required = required
+        .optionalStr = optionalstr
+        .optionalInt = optionalint