Ticket #326: named-params.patch

Source/Members.cobra

@@ -32 +32 @@
     get testMethods as IList<of TestMethod>
 
     def matchesSignature(member as IBoxCodeMember) as bool
-    
+    def getParamNamed(name as String) as Param?
 
 interface IOverloadable inherits IBoxCodeMember
     """
@@ -345 +345 @@
         if (a inherits NilableType) <> (b inherits NilableType)
             return a.nonNil == b.nonNil
         return false
+        
+    def getParamNamed(name as String) as Param?
+        for p in .params, if p.name == name, return p
+        return nil
+        # GenericParams in Methods??    
 
-
     ## Fields
 
     def addMinFields is override

Source/Expr.cobra

@@ -313 +313 @@
             sb.append(', the call is supplying an arglist of type[Utils.plural(args)] "(')
             sep = ''
             for arg in args
-                sb.append('[sep][arg.type.name]')
+                typeName = if(not arg.type , "(unknownType)", arg.type.name)                
+                sb.append('[sep][typeName]')
                 sep=', '
             sb.append(')".')
         return sb.toString
-        
+    
     def throwCannotFindMemberError(receiverExpr as Expr, memberName as String)
         __throwOrRecordCannotFindMemberError(receiverExpr, memberName, 1)
 
@@ -333 +334 @@
             on 2, .recordError(errorMsg)
             else, throw FallThroughException(throwOrRecord)
 
+    def recordCannotFindParamNamed(defn as IBoxCodeMember, name as String)
+        pNames = (for n in defn.params get n.name).join('", "')
+        detail = ' Names for this parameter list are "[pNames]".'
+        .recordError('There is no parameter named "[name]".[detail]') 
+        
+    def recordCannotFindParamNamedOrMember(expr as Expr, defn as IBoxCodeMember, name as String)
+        paramDetail=''
+        if defn.params.count
+            pNames = (for n in defn.params get n.name).join('", "')
+            paramDetail = 'Names for this parameter list are "[pNames]".'
+        memberSuggs = _suggestionsMessage(expr.suggestionsForBadMemberName(name))
+        err = 'There is no parameter named "[name]" and no definition for "[name]" in "[expr.toCobraSource]"[expr.whoseTypeIsMessage].[paramDetail][memberSuggs]' 
+        .recordError(err)
+                
+                
 
 interface IPotentialTypeExpr inherits IExpr
     """
@@ -790 +806 @@
             # if .definition inherits BoxMember and .definition.isMethod and not dotNode.isImplicit
             if (.definition inherits AbstractMethod or .definition inherits MemberOverload) and not dotNode.isImplicit
                 .compiler.warning(this, 'Unnecessary parentheses. You can remove them.')
-        else
+        else if not hasErrors
             for arg in _args
-                if arg inherits AssignExpr
-                    .recordError('Cannot make assignments in arguments. This syntax is reserved in the future for keyword arguments.')
-
+                if arg inherits AssignExpr  # named arg in paramList
+                    hasKeywordArg = true
+                    if not arg.left inherits IdentifierExpr
+                        .recordError('General purpose assignments are not allowed as arguments. Assignment syntax can only be used for keyword arguments.')
+                    else
+                        paramName = (arg.left to IdentifierExpr).name
+                        defn = _definition to IBoxCodeMember
+                        param = defn.getParamNamed(paramName)
+                        if not param
+                            .recordCannotFindParamNamed(defn, paramName)
+                        arg.right.bindImp # 'x=y' has special treatment in arguments
+                else
+                    if hasKeywordArg
+                        .throwError('Cannot have a non-keyword argument ("[arg.toCobraSource]") after a keyword argument. All positional arguments must come before all keyword arguments.')
+                    #arg.bindImp
+            
     ## _bindImp support
 
     def _checkNoArgs(definition as BoxMember, args as IList<of Expr>)
@@ -1909 +1938 @@
 
     var _expr as Expr
     var _args as List<of Expr>
-    var _hasKeywordArg as bool  # such as Foo(1, a=2)
+    var _hasKeywordArg as bool  # such as Foo(1, a=2) # We could almost drop this
     var _isForAttribute as bool  # see Attributes.cobra
     var _helperMethod as Method?
 
@@ -1923 +1952 @@
         base.addSubFields
         .addField('expr', _expr)
         .addField('args', _args)
-        .addField('hasKeywordArg', .hasKeywordArg)
         .addField('isForAttribute', .isForAttribute)
 
     get allExprs as Expr*
@@ -1943 +1971 @@
     get args from var
         has Subnodes
 
-    get hasKeywordArg from var
-
     pro isForAttribute from var
 
     get name as String
@@ -1989 +2015 @@
                 return
         
         expr = expr.bindImp
-
         if expr.definition inherits EnumDecl
             enumCall = EnumCallExpr(.token, expr.toCobraSource, .args, expr.definition).bindImp
             _type = enumCall.type to IType
             _transformTo(enumCall)
             return
 
+        nPropertyInits = _verifyAndBindArgs(expr)
+        _chkTypes(expr)
+        _type ?= _hoistType(expr) # if _type not set in _chkTypes
+
+        #TODO:try and checkout initializer call
+
+        if _hasKeywordArg and nPropertyInits >0 and not .isForAttribute and not .hasError               
+            _makeHelperMethod
+
+    def _verifyAndBindArgs(expr as Expr) as int 
+        """
+        Check that the various argtypes are ordered correctly (positional, named and property-initialising) and 
+        where named refer to valid items (named params or properties). Bind the args for the argtypes
+        """
+        gotInitCall = false
+        nPropInits = nNamedParams =0
+        badOrder= 'Incorrect arg ordering.'
+        detail2 = 'all named parameter keyword arguments must be before all extendedInit (property initialising) keyword arguments'
+        detail =  'All positional arguments must come before all keyword arguments, [detail2]'
         for arg in .args
             try
                 if arg inherits AssignExpr
@@ -2004 +2048 @@
                         .recordError('General purpose assignments are not allowed as arguments. Assignment syntax can only be used for keyword arguments.')
                     else if not expr.receiverType.isDynamicOrPassThrough
                         propertyName = (arg.left to IdentifierExpr).name
-                        if expr.memberForName(propertyName) is nil
-                            .recordCannotFindMemberError(expr, propertyName)
+                        if expr.memberForName(propertyName) #assign to property name post ctor (extended init)
+                            nPropInits += 1
+                        else
+                            if not gotInitCall # lazy best Initializer determination
+                                initCall = _bestInitializer
+                                gotInitCall = true
+                            defn = initCall to? IBoxCodeMember
+                            if defn 
+                                if defn.getParamNamed(propertyName) #actually a named parameter 
+                                    nNamedParams += 1
+                                    if nPropInits
+                                        .recordError('[badOrder] Cannot have a named parameter argument ("[arg.toCobraSource]") after a keyword property initialising argument. [detail]')
+                                else    
+                                    .recordCannotFindParamNamedOrMember(expr, defn, propertyName)
+
                     arg.right.bindImp  # 'x=y' has special treatment in arguments
                 else
                     if _hasKeywordArg
-                        .throwError('Cannot have a non-keyword argument ("[arg.toCobraSource]") after a keyword argument. All positional arguments must come before all keyword arguments.')
+                        .throwError('[badOrder] Cannot have a positional non-keyword argument ("[arg.toCobraSource]") after a keyword argument. [detail]')
                     arg.bindImp
             catch ne as NodeException
                 .compiler.recordError(ne)
-
+        return nPropInits
+            
+    def _bestInitializer as Initializer?
+        # Since this is determining best Initializer choice from the provided args list we can still get 
+        # a bad result if the args include named params and the order is different from that in the decl.
+        # OTOH using named params and default params should mean that there is only a single (well defaulted)
+        # Initializer anyway...
+        initCall = nil
+        if _expr.definition inherits ClassOrStruct  # Class/Struct(o) MethodSig(?), Interface/Mixin(x)
+            initdefn = _expr.memberForName('cue.init')
+            if initdefn inherits BoxMember
+                args = _argsToCallArgs
+                if initdefn inherits MemberOverload
+                    initCall = initdefn.computeBestOverload( args, nil, false) to Initializer?
+                    #isOverload = true
+                else if initdefn inherits Initializer
+                    initCall = initdefn
+                # TODO: verify args and params match exactly re count, assignability
+                # maybe adjust inheritance tree to use code from CallExpr...
+                /# 
+                params = initCall.params
+                print params
+                if initCall inherits BoxMember # .no-warnings.
+                    if not initdefn.hasParams
+                        _checkNoArgs(initCall, args)
+                    else
+                        params = initCall.params
+                        if _checkParamsCount(initCall, args, params)
+                            _checkArgsAssignable(initCall, isOverload, args, params)
+                                
+                _checkVisibility(definition, expr)
+                #/
+            else
+                throw FallThroughException(initdefn)
+        return initCall         
+    
+    def _argsToCallArgs as List<of Expr>
+        """get Positional and named args only - AssignExpr whose Identifier names are not property names."""
+        cleanArgs = List<of Expr>()
+        for arg in .args
+            if arg inherits AssignExpr 
+                if arg.left inherits IdentifierExpr
+                    member = _expr.memberForName((arg.left to IdentifierExpr).name)
+                if member, continue # extended init property assignment
+            cleanArgs.add(arg) #positional arg or named (paramName=value) arg
+        return cleanArgs
+        
+    def _chkTypes(expr as Expr)
+        """Make sure expr is one of supported grabbag of Types for a PostCallExpr or complain bitterly."""
         if expr inherits TypeExpr
             # instantiation
             assert expr.containedType
@@ -2037 +2142 @@
             # which yielded: PostCallExpr(expr=ToExpr(...))
             # TODO: can probably make this an error now
             assert false, _expr
-
-        if _type is nil
-            assert expr.type is not nil
-            exprType = expr.type.nonNil
-            if exprType inherits MethodSig
-                _type = exprType.returnType
-            else if exprType.isDescendantOf(.compiler.delegateType)
-                member = exprType.memberForName('invoke')
-                if member inherits Method
-                    _type = member.resultType
-                else
-                    .throwError('Cannot find a single "invoke" method for "_eventType.name".')
-            else if expr.receiverType and expr.receiverType.nonNil.isSystemTypeClass
-                _type = .compiler.dynamicType
-            else if exprType inherits Box
-                _type = expr.receiverType  # for example, an IdentifierExpr of 'SomeClass' has a .receiverType of that class
-                _handleClassInitializer
-            else if exprType.isDynamic
-                _type = .compiler.nilableDynamicType
-            else if expr.definition inherits NameSpace
-                .throwError('Cannot instantiate the namespace "[(expr.definition to NameSpace).fullName]".')
-            else if exprType == .typeProvider.passThroughType
-                _type = .typeProvider.passThroughType
+        
+    def _hoistType(expr as Expr) as IType?
+        """Obtain supported-expression type for the postCallExpr's type."""
+        assert expr.type is not nil
+        exprType = expr.type.nonNil
+        if exprType inherits MethodSig
+            type = exprType.returnType
+        else if exprType.isDescendantOf(.compiler.delegateType)
+            member = exprType.memberForName('invoke')
+            if member inherits Method
+                type = member.resultType
             else
-                trace .idString, expr.idString, exprType.idString
-                trace this, expr
-                assert false, expr
+                .throwError('Cannot find a single "invoke" method for "_eventType.name".')
+        else if expr.receiverType and expr.receiverType.nonNil.isSystemTypeClass
+            type = .compiler.dynamicType
+        else if exprType inherits Box
+            type = expr.receiverType  # for example, an IdentifierExpr of 'SomeClass' has a .receiverType of that class
+            _handleClassInitializer
+        else if exprType.isDynamic
+            type = .compiler.nilableDynamicType
+        else if expr.definition inherits NameSpace
+            .throwError('Cannot instantiate the namespace "[(expr.definition to NameSpace).fullName]".')
+        else if exprType == .typeProvider.passThroughType
+            type = .typeProvider.passThroughType
+        else
+            trace .idString, expr.idString, exprType.idString
+            trace this, expr
+            assert false, expr
 
-        if .hasKeywordArg and not .isForAttribute and not .hasError
-            _makeHelperMethod
+        return type
             
     def _makeHelperMethod
         """
         Add a private helper method to the current box to support extended initializer.
-
-        Foo(expr0, expr1, bar=expr2) -->
+        Pass through any named parameter args.
+        
+        Foo(expr0, expr1, paramName=expr2, bar=expr3) -->
             call:
-                _ch_ext_init_1207(expr0, expr1, expr2)
+                _ch_ext_init_1207(expr0, expr1, expr2, expr3)
             def:
-                def _ch_ext_init_1207(arg0 as int, arg1 as int, /#bar=#/arg2 as int)
-                    obj = Foo(arg0, arg1)
-                    obj.bar = arg2
+                def _ch_ext_init_1207(arg0 as int, arg1 as int, arg2 as int, /#bar=#/arg3 as int)
+                    obj = Foo(arg0, arg1, paramName=arg2)
+                    obj.bar = arg3
                     return obj
         """
         box, token = .compiler.curBox, box.token.copy
-        paramsForDecl = List<of Param>()
-        argsForInitCall = List<of Expr>()  # args to pass to `Foo(arg0, arg1)`
-        propsToSet = List<of AssignExpr>()  # props to set as `obj.bar = arg2` etc.
+        paramsForDecl = List<of Param>()   # parameters for helper method
+        argsForInitCall = List<of Expr>()  # args to pass in call to `Foo(arg0, arg1)`
+        propsToSet = List<of AssignExpr>() # Extended init props to set as `obj.bar = arg2` etc.
         firstPropArg = -1
         for i, arg in .args.numbered
+            helperParamName = 'arg[i]'
             if arg inherits AssignExpr
-                propsToSet.add(arg)
-                if firstPropArg == -1, firstPropArg = i
                 propertyName = (arg.left to IdentifierExpr).name
-                argType = _expr.memberForName(propertyName).resultType
-                arg = arg.right
+                member = _expr.memberForName(propertyName)
+                if member # ext Init property set
+                    propsToSet.add(arg)
+                    if firstPropArg == -1, firstPropArg = i
+                    argType = member.resultType
+                    #arg = arg.right
+                else # named arg
+                    helperParam = IdentifierExpr(token.copy('ID', helperParamName))
+                    helperNamedArg = AssignExpr(token.copy('ASSIGN', '='), 'ASSIGN', arg.left, helperParam)
+                    argsForInitCall.add(helperNamedArg)
+                    argType = arg.right.type to !
+                    #arg = arg.right
             else
-                argsForInitCall.add(if(arg inherits NilLiteral, arg, IdentifierExpr(token.copy('ID', 'arg[i]'))))
+                argsForInitCall.add(if(arg inherits NilLiteral, arg, IdentifierExpr(token.copy('ID', helperParamName))))
                 argType = arg.type to !
-            paramsForDecl.add(Param(box.token.copy('ID', 'arg[i]'), argType))
+            paramsForDecl.add(Param(box.token.copy('ID', helperParamName), argType))
         name = '_ch_ext_init_[.serialNum]'  # ch = class helper, ext = extended, init = initializer
         if .compiler.codeMemberStack.count
             curMember = .compiler.curCodeMember

Source/BackEndClr/SharpGenerator.cobra

@@ -544 +544 @@
         d = writer.curlyToCobraLineNum
 
         # Output
+        #print 'Output: ', writer.output
         (.compiler to Compiler).createSharpFile(.sharpFileName, writer.output)
 
         return d
@@ -3280 +3281 @@
         sep = ''
         for arg in _args
             sw.write(sep)
-            arg.writeSharpDefInContext(sw)
+            if arg inherits AssignExpr  #   .Net4.0 Named parameter
+                # cant do arg.left.writeSharpDef as binding invariants are incomplete
+                sw.write((arg.left to IdentifierExpr).name) 
+                sw.write(':')               # C# form is name:value
+                arg.right.writeSharpDef(sw)
+            else    
+                arg.writeSharpDefInContext(sw)
             sep = ', '
         sw.write(')')
 
@@ -3707 +3714 @@
     def writeSharpArgs(sw as CurlyWriter, sep as String)
         for arg in _args
             sw.write(sep)
-            arg.writeSharpDefInContext(sw, false)
+            if arg inherits AssignExpr  #   .Net4.0 Named parameter
+                # cant do arg.left.writeSharpDef as binding invariants are incomplete
+                sw.write((arg.left to IdentifierExpr).name) 
+                sw.write(':')               # C# form is name:value
+                arg.right.writeSharpDef(sw)
+            else    
+                arg.writeSharpDefInContext(sw, false)
             sep = ','
         
     def writeSharpBreakdownItems(sw as CurlyWriter)

Source/BackEndJvm/JavaGenerator.cobra

@@ -1324 +1324 @@
             on Direction.InOut, sw.write('/*inOut*/')   # default
             on Direction.Out, sw.write('/*out*/')       # TODO
         sw.write('[.type.javaParamRef] [.javaName]')
-#       if .optionalValue
-#           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]')
+        if .optionalValue
+            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]')
+            # TODO: higher up write variant method that calls full param set method with default value curried in
 #           #sw.write('=')
 #           #_optValue.writeSharpDef(sw)
 
@@ -3034 +3035 @@
         sep = ''
         for arg in _args
             sw.write(sep)
-            arg.writeJavaDefInContext(sw)
+            if arg inherits AssignExpr  #    Named parameter
+                detail = 'For java at the moment you will need to recode the named parameter call to a call using positional arguments.'
+                .compiler.warning(this, 'Java does not support named parameters in calls so these are not available with this backend. [detail]')
+                # TODO: Rewrite call to positional parameter form using name(s) given
+                ## cant do arg.left.writeSharpDef as binding invariants are incomplete
+                #sw.write((arg.left to IdentifierExpr).name) 
+                #sw.write(':')              # C# form is name:value
+                arg.right.writeJavaDef(sw)
+            else    
+                arg.writeJavaDefInContext(sw)
             sep = ', '
         sw.write(')')
 
@@ -4627 +4637 @@
     def writeJavaArgs(sw as CurlyWriter, sep as String)
         for arg in _args
             sw.write(sep)
-            arg.writeJavaDefInContext(sw, false)
+            if arg inherits AssignExpr  #    Named parameter
+                detail = 'For java at the moment you will need to recode the named parameter call to a call using positional arguments.'
+                .compiler.warning(this, 'Java does not support named parameters in calls so these are are not available with this backend. [detail]')
+                # TODO: Rewrite call to positional parameter form using name(s) given
+                ## cant do arg.left.writeSharpDef as binding invariants are incomplete
+                #sw.write((arg.left to IdentifierExpr).name) 
+                #sw.write(':')              # C# form is name:value
+                arg.right.writeJavaDef(sw)
+            else    
+                arg.writeJavaDefInContext(sw, false)
             sep = ','
         
     def writeJavaBreakdownItems(sw as CurlyWriter)

Tests/820-errors/200-expressions/150-no-assignments-in-args.cobra

@@ -1 +1 @@
 class Test
 
     def main is shared
-        Test().foo(x = 2)  # .error. Cannot make assignments in arguments.
+        Test().foo(x = 2)  # .error. no parameter named "x".
 
     cue init
         base.init

Tests/120-classes/400-methods/600-named-params/820-name-mismatch.cobra

@@ +1 @@
+class NamedCtor
+    def main is shared
+
+        x1 = NamedCtor(sname='foo', age=99) #.error. No parameter named "sname" and no definition
+        assert x1.x == 'foo'
+        assert x1.a == 99
+        
+    var x = ''
+    var a = 0
+    
+    cue init(sName as String, age as int)   
+        base.init
+        .x = sName
+        .a = age
+        
+        

Tests/120-classes/400-methods/600-named-params/802-too-many-params.cobra

@@ +1 @@
+# fixed plus single named param + used optional + ext property init
+class OptParam
+    def main is shared
+        
+        x = OptParam()
+        x.foo('default')
+        assert x.value == 0
+        assert x.value1 == 0
+
+        # can only set props like this in ctor calls
+        x.foo('opt', 45, value1=66 ) #.error. no parameter named "value1"
+        assert x.value ==45
+        assert x.value1 ==1
+
+    var value  = 0
+    var value1 = 0
+    
+    def foo(s as String, nmd as int = 0, nmd1 as int = 0)
+        .value = nmd
+        if s =='default', assert nmd1 == 0
+        .value1 = nmd1
+        

Tests/120-classes/400-methods/600-named-params/826-order-mismatch.cobra

@@ +1 @@
+class NamedCtor
+    def main is shared
+
+        x1 = NamedCtor(sName='foo', age=99)
+        assert x1.x == 'foo'
+        assert x1.a == 99
+        
+        x2 = NamedCtor(xcomb=88, sName='foo') #.error. Incorrect arg ordering
+        assert x2.x == 'wrong' # notReached
+        assert x2.a == 55
+        assert x2.xcomb == 88
+        assert x2.ycomb == 0
+        
+        x2 = NamedCtor(xcomb=88, ycomb=99, sName='foo') #.error. Incorrect arg ordering
+        assert x2.x == 'wrong' # notReached
+        assert x2.a == 55
+        assert x2.xcomb == 88
+        assert x2.ycomb == 99
+        
+        x3 = NamedCtor(xcomb=88, ycomb=99, 55) #.error. Incorrect arg ordering
+        assert x3.x == 'wrong' # notReached
+        assert x3.a == 55
+        assert x3.xcomb == 88
+        assert x3.ycomb == 99
+
+    var x = ''
+    var a = 0
+    pro xcomb from var = 0
+    pro ycomb from var = 0
+    
+    cue init(sName as String = 'fou', age as int = 55)  
+        base.init
+        .x = sName
+        .a = age
+        
+        

Tests/120-classes/400-methods/600-named-params/804-too-many-params.cobra

@@ +1 @@
+# fixed plus single named param + used optional + ext property init
+class OptParam
+    def main is shared
+        
+        x = OptParam()
+        x.foo('default', 44 )
+        assert x.value == 44
+        assert x.value1 == 0
+
+        # valid named arg but already supplied by positional args
+        x.foo('opt', 45, 1, nmd1=66 ) #.error. expecting 3 arguments, but 4 are being supplied
+        assert x.value ==45
+        assert x.value1 ==66
+
+    var value  = 0
+    var value1 = 0
+    
+    def foo(s as String, nmd as int, nmd1 as int = 0)
+        .value = nmd
+        if s =='default', assert nmd1 == 0
+        .value1 = nmd1
+        

Tests/120-classes/400-methods/600-named-params/810-no-param-named.cobra

@@ +1 @@
+# fixed plus single named param - errors
+class OptParam
+    def main is shared
+        x = OptParam()
+        x.call = 0
+        x.foo('default', badName = 44) # .error. no parameter
+        assert x.call ==44
+
+    var call = 0
+    
+    def foo(s as String, nmd as int )
+        #print s,i
+        .call = nmd
+

Tests/120-classes/400-methods/600-named-params/110-named-params.cobra

@@ +1 @@
+# fixed plus single named param
+class OptParam
+    def main is shared
+        x = OptParam()
+        x.value = 0
+        x.foo('default', nmd=44)
+        assert x.value ==44
+            
+        x.foo(nmd = 45, s='default')
+        assert x.value ==45
+
+    var value = 0
+    
+    def foo(s as String, nmd as int )
+        #print s,i
+        .value = nmd
+

Tests/120-classes/400-methods/600-named-params/815-order-error.cobra

@@ +1 @@
+# fixed plus single named param + used optional
+class OptParam
+    def main is shared
+        x = OptParam()
+        x.value = 0
+        x.foo('default', nmd=44 )
+        assert x.value ==44
+
+        x.foo('opt', nmd=50, 10 ) #.error. positional arguments must come before all keyword arguments
+        assert x.value ==50
+        
+    var value = 0
+    
+    def foo(s as String, nmd as int, nmd2 as int = 0)
+        #print s,i
+        trace nmd
+        .value = nmd
+        if s =='default', assert nmd2 == 0
+        trace nmd2
+        .value += nmd2
+

Tests/120-classes/400-methods/600-named-params/850-badInit.cobra

@@ +1 @@
+# Change this later when add Initializer checks
+class BadI
+    def main is shared
+        x = BadI('default', 0, 10) #.error. not contain an initializer that takes 3 arguments
+        CobraCore.noOp(x)
+            
+    var x = ''
+    var a = 0
+    
+    cue init(sName as String, age as int)   # .warning. previous error
+        base.init
+        .x = sName
+        .a = age
+        #print 'NamedCtor [.x]'
+    

Tests/120-classes/400-methods/600-named-params/600-named-and-opt-and-ext.cobra

@@ +1 @@
+# fixed plus single named param + used optional + ext property init
+class OptParam
+    def main is shared
+        
+        x = OptParam('default', nmd=45 )
+        assert x.value ==45
+        assert x.value1 ==0
+        assert x.value2 ==0
+
+        x = OptParam('opt', 45, 1, value2=66 )
+        assert x.value ==45
+        assert x.value1 ==1
+        assert x.value2 ==66
+        
+        x = OptParam('opt', 0, nmd1=50, value2=67 )
+        assert x.value ==0
+        assert x.value1 ==50
+        assert x.value2 ==67
+        
+        x = OptParam('opt', nmd1=1, nmd=51, value2=68 )
+        assert x.value ==51
+        assert x.value1 ==1
+        assert x.value2 ==68
+    
+        x = OptParam('opt', nmd1=1, nmd=51, value1=55 )
+        assert x.value ==51
+        assert x.value1 ==55
+        assert x.value2 ==0
+        
+        x = OptParam('opt', nmd1=99, nmd=55, value=66, value1=77 )
+        assert x.value  ==66
+        assert x.value1 ==77
+        assert x.value2 ==0
+        
+        x = OptParam('opt', nmd1=99, nmd=55, value=66, value1=77, value2=88 )
+        assert x.value  ==66
+        assert x.value1 ==77
+        assert x.value2 ==88
+        
+    var value = 0
+    var value1 = 0
+    var value2 = 0
+    
+    cue init(s as String, nmd as int, nmd1 as int = 0)
+        base.init
+        #trace nmd
+        .value = nmd
+        if s =='default', assert nmd1 == 0
+        #trace nmd1
+        .value1 = nmd1
+    

Tests/120-classes/400-methods/600-named-params/500-named-and-opt.cobra

@@ +1 @@
+# fixed plus single named param + unused optional param
+class OptParam
+    def main is shared
+        x = OptParam()
+        x.value = 0
+        x.foo('default', nmd=44 )
+        assert x.value ==44
+        
+        x.value = 0
+        x.foo('opt', nmd=10, nmd2=34)
+        assert x.value ==44
+
+        x.value = 0
+        x.foo('opt', nmd2=1, nmd=44)
+        assert x.value ==45
+    
+        
+    var value = 0
+    
+    def foo(s as String, nmd as int, nmd2 as int = 0)
+        .value = nmd
+        .value += nmd2
+

Tests/120-classes/400-methods/600-named-params/822-order-mismatch.cobra

@@ +1 @@
+class NamedCtor
+    def main is shared
+
+        x1 = NamedCtor(sName='foo', age=99)
+        assert x1.x == 'foo'
+        assert x1.a == 99
+        
+        x2 = NamedCtor(age=55, xcomb=88, ycomb=99, sName='wrong') #.error. Incorrect arg ordering
+        assert x2.x == 'wrong'
+        assert x2.a == 55
+        assert x2.xcomb == 88
+        assert x2.ycomb == 99
+        
+    var x = ''
+    var a = 0
+    pro xcomb from var = 0
+    pro ycomb from var = 0
+    
+    cue init(sName as String, age as int)   
+        base.init
+        .x = sName
+        .a = age
+        
+        

Tests/120-classes/400-methods/600-named-params/510-named-and-opt.cobra

@@ +1 @@
+# fixed plus single named param + used optional
+class OptParam
+    def main is shared
+        x = OptParam()
+        x.clr
+        x.foo('default', 44 )
+        assert x.value == 44
+        assert x.value1 == 0
+        
+        x.clr
+        assert x.value ==0 and x.value1 ==0
+        x.foo('default', nmd=45 )
+        assert x.value ==45
+        assert x.value1 ==0
+
+        x.clr
+        x.foo('opt', 45, 1 )
+        assert x.value ==45
+        assert x.value1 ==1
+        
+        x.clr
+        x.foo('opt', 0, nmd2=50 )
+        assert x.value ==0
+        assert x.value1 ==50
+        
+        x.clr
+        x.foo('opt', nmd2=1, nmd=51 )
+        assert x.value ==51
+        assert x.value1 ==1
+    
+        x.clr
+        x.foo('opt', nmd2=99, nmd=55 )
+        assert x.value ==55
+        assert x.value1 ==99
+        
+    var value = 0
+    var value1 = 0
+    
+    def foo(s as String, nmd as int, nmd2 as int = 0)
+        #trace nmd
+        .value = nmd
+        if s =='default', assert nmd2 == 0
+        #trace nmd2
+        .value1 = nmd2
+    
+    def clr
+        .value = .value1 = 0    

Tests/120-classes/400-methods/600-named-params/420-named-param-ext-ctor.cobra

@@ +1 @@
+class NamedCtor
+    def main is shared
+
+        x1 = NamedCtor(sName='foo', age=99)
+        assert x1.x == 'foo'
+        assert x1.a == 99
+        
+        x2 = NamedCtor(age=55, sName='foo', ycomb=99)
+        assert x2.x == 'foo'
+        assert x2.a == 55
+        assert x2.ycomb == 99
+        
+    var x = ''
+    var a = 0
+    pro ycomb from var = 0
+    
+    cue init(sName as String, age as int)   
+        base.init
+        .x = sName
+        .a = age
+        #print 'NamedCtor [.x]'
+        
+        

Tests/120-classes/400-methods/600-named-params/824-order-mismatch.cobra

@@ +1 @@
+class NamedCtor
+    def main is shared
+
+        x1 = NamedCtor(sName='foo', age=99)
+        assert x1.x == 'foo'
+        assert x1.a == 99
+        
+        x2 = NamedCtor("foo", xcomb=88, ycomb=99, 55) #.error. Incorrect arg ordering
+        assert x2.x == 'wrong'
+        assert x2.a == 55
+        assert x2.xcomb == 88
+        assert x2.ycomb == 99
+        
+    var x = ''
+    var a = 0
+    pro xcomb from var = 0
+    pro ycomb from var = 0
+    
+    cue init(sName as String, age as int)   
+        base.init
+        .x = sName
+        .a = age
+        
+        

Tests/120-classes/400-methods/600-named-params/410-named-param-ctor.cobra

@@ +1 @@
+class NamedCtor
+    def main is shared
+        x = NamedCtor('default', 0)
+        assert x.x == 'default'
+        assert x.a == 0
+
+        x1 = NamedCtor(sName='foo', age=99)
+        assert x1.x == 'foo'
+        assert x1.a == 99
+        
+        x2 = NamedCtor(age=55, sName='foo')
+        assert x2.x == 'foo'
+        assert x2.a == 55
+        
+    var x = ''
+    var a = 0
+    
+    cue init(sName as String, age as int)   
+        base.init
+        .x = sName
+        .a = age
+        #print 'NamedCtor [.x]'
+        
+        

Tests/120-classes/400-methods/600-named-params/800-too-many-params.cobra

@@ +1 @@
+# fixed plus single named param + used optional + ext property init
+class OptParam
+    def main is shared
+        
+        x = OptParam()
+        x.foo('default', 44 )
+        assert x.value == 44
+        assert x.value1 == 0
+
+        # can only set props like this in ctor calls
+        x.foo('opt', 45, 1, value1=66 ) #.error. expecting 3 arguments, but 4 are being supplied
+        assert x.value ==45
+        assert x.value1 ==1
+
+    var value  = 0
+    var value1 = 0
+    
+    def foo(s as String, nmd as int, nmd1 as int = 0)
+        .value = nmd
+        if s =='default', assert nmd1 == 0
+        .value1 = nmd1
+        

Tests/120-classes/322-construct-prop-set-error.cobra

@@ -8 +8 @@
 
     def main is shared
         x = X(t=5)
-        x = X(u=5)  # .error. cannot find
+        x = X(u=5)  # .error. no parameter named "u" and no definition for "u"
         print x