Ticket #39: ref-lambda-type-inference-target-local.patch

Source/Members.cobra

@@ -596 +596 @@
     get shouldBeVirtual as bool is override
         return false
 
-    def lambdaReturnType as IType
+    def inferLambdaReturnType # as IType
         """ This is a service method for LambdaExpr. """
         require .didBindInt and .didBindImp
         stmt = _stmts[0]
         if stmt inherits ReturnStmt
-            return stmt.expr.type to !
+            if stmt.expr.type
+                _returnType =  stmt.expr.type to !
         else
             throw FallThroughException(stmt)
-
+            
+    def inferReturnType
+        """ 
+        Infer returntype from (first) return statement if type not already explicitly set.
+        This is a service method for AnonymousMethodExpr.
+        """
+        require .didBindInt and .didBindImp
+        if _returnType == .compiler.passThroughType
+            for stmt in _stmts
+                if stmt inherits ReturnStmt 
+                    if stmt.expr.type
+                        _returnType = stmt.expr.type to !
+                        break
+        
     def _bindInt is override
         base._bindInt
         if _returnTypeNode is nil
-            _returnType = .compiler.passThroughType  # TODO: infer return type from return statement like C# does
+            _returnType = .compiler.passThroughType 
 
 # uu
     def _bindImp is override
@@ -628 +642 @@
                 break
         if hasYield, .throwError('Cannot yield inside an anonymous method.')
 
-
 class AbstractMethod
     is abstract, partial
     inherits BoxMember

Source/Expr.cobra

@@ -210 +210 @@
         body
             base._bindImp
 
+    def _findMatchingSig(aSig as MethodSig, container as Box, searchHier as bool) as MethodSig?
+        """
+        Look for a compatible matching Sig for asig in container.
+        Check in only the container if searchHier is false or that and all of containers ancestor inheritance hierarchy 
+            if searchHier is true.
+        Return any matching sig if found otherwise return nil
+        
+        Support method for type inference on RefExpr and AnonymousMethod and LambdaExpr
+        """
+            
+        compatSig = container.sigForMethodSig(aSig, searchHier)
+        return compatSig
+        
+        
+    def _actionMissingSig(aSig as MethodSig, container as Box, tag as String)
+        msg    = 'No signature matching the signature of the [tag] ([aSig.toCobraSource]) in the inheritance tree or used namespaces.'
+        sugg   = 'Did you leave out a sig statement in scope for this method reference?'
+        action = 'Adding generated sig "[aSig.toCobraSource]" to [container.name]'
+        .compiler.warning(this, '[msg]\n[sugg]\n[action]')
+        container.addDecl(aSig) # It may be preferable to not do this and defer back to non inference
+                
     def _suggestionsMessage(suggs as List<of String>) as String
         """
         Shared by MemberExpr, CallExpr and IdentifierExpr to give suggestions in an error message about an unknown member.
@@ -328 +349 @@
         base.addSubFields
         .addField('params', .params)
 
+    def _makeAnonSig(tag as String, resultType as IType, isNames as String*) as MethodSig
+        """
+        Make an anonymous methodSig for this anonymous expr (lambda or anonMethod)
+        and return a declared match for it or instantiate it into its containing box. 
+        """
+        sigToken  = .token.copy('ID', 'sigFor[tag]') 
+        nameToken = .token.copy('ID', 'SigFor[tag]_[.token.lineNum]_[.serialNum]')
+        docString = '' to ?
+        aSig = MethodSig(sigToken, nameToken, .curCodeMember.parentBox, nameToken.text, .params, 
+            resultType, isNames, AttributeList(), docString)
+        aSig.bindInh
+        aSig.bindInt
+        aSig.bindImp
+        #print aSig
+        return _matchingOrNewSig(aSig, .curCodeMember.parentBox, tag) # in Expr
+            
+    def _matchingOrNewSig(aSig as MethodSig, container as Box, tag as String) as MethodSig
+        """
+        Return a compatible matching Sig for asig found in container and containers ancestor inheritance hierarchy 
+        if one is not found warn, insert (instantiate) aSig into container and return it.
+        
+        Support method for type inference on AnonymousMethod and LambdaExpr
+        """
+        compatSig = _findMatchingSig(aSig, container, true)
+        if not compatSig    # not found
+            _actionMissingSig(aSig, container, tag)
+        else
+            aSig = compatSig to !
+        return aSig 
+    
+        
     def toCobraSource as String is override
         sb = StringBuilder('do(')
         sep = ''
@@ -343 +395 @@
 class AnonymousMethodExpr inherits AnonymousExpr is partial
     implements HasAddStmt
     """
+    do(a as int, b as int) as int
+        ...
+        return a.compareTo(b)
+
     Also called "closures".
     """
     
@@ -362 +418 @@
 
     def _bindImp is override
         base._bindImp
-        _method = AnonymousMethod(.token, .curCodeMember, .params, _returnTypeProxy, if(.curCodeMember.isShared, ['shared'], List<of String>()))
+        isNames = if(.curCodeMember.isShared, ['shared'], List<of String>())
+        _method = AnonymousMethod(.token, .curCodeMember, .params, _returnTypeProxy, isNames)
         for stmt in .stmts, _method.addStmt(stmt)
         _method.bindInt
         _method.bindImp
-        _type = _method.resultType
+        _method.inferReturnType 
+        #print .token.lineNum, _method.resultType
+        _type = _makeAnonSig('AnonMthd', _method.resultType, List<of String>())
+    
 
-
 class LambdaExpr inherits AnonymousExpr is partial
     """
     ... do(a as int, b as int)=a.compareTo(b) ...
@@ -400 +459 @@
 
     def _bindImp is override
         base._bindImp
-        _method = AnonymousMethod(.token, .curCodeMember, .params, .compiler.dynamicType, if(.curCodeMember.isShared, ['shared'], List<of String>()))
+        isNames = if(.curCodeMember.isShared, ['shared'], List<of String>())
+        _method = AnonymousMethod(.token, .curCodeMember, .params,  .compiler.dynamicType, isNames)
         ret = ReturnStmt(.token.copy('RETURN', 'return'), .expr)
         _method.addStmt(ret)
         _method.bindInt
         _method.bindImp
         # the expression may have been transformed, but if so, only the containing ReturnStmt got the notice
         _expr = ret.expr to !
-        _type = .compiler.passThroughType # TODO: Set a real type such as .compiler.delegateType
-        # method.lambdaReturnType
+        _type = .compiler.passThroughType
+        _method.inferLambdaReturnType
+        _type = _makeAnonSig('Lambda', _method.resultType, isNames)
 
 
 class AsExpr
@@ -1913 +1974 @@
         ref obj.foo
         ref _foo
     """
-
+    
+    var _refSig as MethodSig?       
+    
     cue init(token as IToken, expr as Expr)
         base.init(token)
         # TODO: can the types of expressions be limited?
@@ -1947 +2010 @@
             throw
         finally
             .compiler.refExprLevel -= 1
+        _checkRefExpr   
+        _type = .compiler.passThroughType # something if refSig make signature fails
+        refSig = _makeSignatureOfExpr
+        if refSig
+            refSig.bindInh
+            refSig.bindInt
+            refSig.bindImp
+            container = .compiler.curCodeMember.parentBox
+            sigType as IType? = _findMatchingSig(refSig, container, true)  # container and inheritance chain
+            if sigType # match found
+                _type = sigType
+            else    
+                # Defer search till post assignment and target is another Box member
+                # Hack for (forward) access to local sig in unrelated class
+                _refSig = refSig    # stash for later
+                _type = .compiler.passThroughType 
+                if _inSimpleAssignment
+                    .missingSig(container)
+        assert _type
+                
+    def _inSimpleAssignment as bool
+        assert _expr.superNode inherits RefExpr
+        node = _expr.superNode.superNode
+        if node inherits AssignExpr 
+            if node.left inherits IdentifierExpr
+                return true
+        return false
+
+    
+    def _checkRefExpr   
         if _expr inherits DotExpr
             right = _expr.right
             if right inherits MemberExpr
@@ -1962 +2055 @@
             else
                 throw FallThroughException([this, _expr, right])
         else if _expr inherits IdentifierExpr
-            if _expr.definition inherits AbstractMethod
-                pass
-            else
+            if not ( _expr.definition inherits AbstractMethod )
                 .throwError('Only methods can be referenced, not [Utils.pluralize(_expr.definition.englishName)].')
         else
             .throwError('Unexpected reference. Refer to methods after `ref` or remove `ref`.')
-        _type = .compiler.passThroughType # TODO: Set a real type such as .compiler.delegateType
-        # TODO: need to do something more sophisticated like overriding:    def canBeAssignedTo(type as IType) as bool
 
+    def _makeSignatureOfExpr as MethodSig?
+        """Auto generate a signature for type of expression being 'ref'd""" 
+        if _expr inherits DotExpr
+            right = _expr.right
+            if right inherits MemberExpr
+                if right.definition inherits AbstractMethod 
+                    am = right.definition to AbstractMethod
+                    signature = _makeSig(am, _expr.right.token)
+                else if right.definition inherits MemberOverload
+                    mo = right.definition to MemberOverload
+                    if mo.members[0] inherits AbstractMethod
+                        am = mo.members[0] to AbstractMethod 
+                        signature = _makeSig(am, _expr.right.token)
+        else if _expr inherits IdentifierExpr
+            if _expr.definition inherits AbstractMethod
+                am = _expr.definition to AbstractMethod
+                signature = _makeSig(am, _expr.token)
+        return signature
+            
+    def _makeSig(am as AbstractMethod, token as IToken) as MethodSig
+        """Make an (anonymously named) signature corresponding to the provided method"""
+        sigToken= token.copy('ID', 'sigForRef') 
+        nameToken = token.copy 
+        container = .compiler.curCodeMember.parentBox
+        name = 'SigFor_'+nameToken.value to String
+        isNames = List<of String>()
+        attribs = AttributeList()
+        docString = '' to ?
+        returnType = am.resultType
+        params     = List<of Param>(am.params)
+        return MethodSig(sigToken, nameToken, container, name, params, returnType, isNames, attribs, docString)
+        
+    def tryForLocalSig(container as Box)
+        """ 
+        Look for matching sig in given container (one level lookup). 
+        Use it if found otherwise use synthesized sig of expr
+            
+        call only after bindImp already done
+        This is support for methodType inference for a class local sig decl
+        """
+        assert _refSig  
+        refSig = _refSig to !   
+        sigType = _findMatchingSig(refSig, container, false) # container only
+        if sigType # match found
+            _type = sigType
+        else
+            .missingSig(container) 
+            
+    def missingSig(container as Box)
+        """ No matching sig found, setup to use synthesized Sig."""
+        assert _refSig  
+        refSig = _refSig to !   
+        _actionMissingSig(refSig, container, _expr.definition.name) 
+        _type = refSig
+        
     def toCobraSource as String is override
         return 'ref ' + _expr.toCobraSource
 

Source/BackEndClr/ScanClrType.cobra

@@ -55 +55 @@
                     if type.isClass
                         if type.name.startsWith('Extend_') and type.name.count(c'_') >= 2
                             curNameSpace.addDecl(Extension(clrType))
+                        else if _shouldBeMethodSig(type)
+                            #print curNameSpace.name, type.name 
+                            curNameSpace.addDecl(MethodSig(clrType))
                         else
                             curNameSpace.addDecl(Class(clrType))
                     else if type.isInterface
@@ -70 +73 @@
                         throw FallThroughException(type)
         finally
             _curModule = saveModule
+            
+    def _shouldBeMethodSig(type as Type) as bool
+        if not type.isSubclassOf(System.MulticastDelegate)
+            return false
+        #if type.isGenericType
+        #   print type.namespace, type.name 
 
+        # Below delegates are generic types in System that are 'too' general re params and return types
+        # and give 'false' matches for simple common cases (min params and (no) return types)
+        # so we suppress them. 
+        #Inferred uses will probably either need an explicit compatible signature or will get a warning generated...
+        if type.name in ['CrossAppDomainDelegate', 'Converter`2', 'Action`1', 'EventHandler`1']
+            return false    # other possible candidates include Predicate`1 
+        return true
+            
     def fixNilableMemberSigs
         # TODO: this really needs to go in a separate file that the compiler reads each time
 
@@ -479 +496 @@
 
     def _memberTypeProxy(clrType as Type?, notNullAttr as bool) as ITypeProxy
         """
-        Returns a type proxy for a member type such as a parameter type or method return type.
+        Returns a type proxy for a member type such as a parameter type or member type.
         In CLR, reference types are nilable by default, but you can pass `true` for `notNullAttr` to indicate there was a NotNullAttribute in the DLL.
         """
         if clrType is nil
@@ -495 +512 @@
 
     def _memberTypeResultProxy(member as MemberInfo, clrType as Type?) as ITypeProxy
         """
-        Returns a type proxy for a member type such as a parameter type or method return type.
+        Returns a type proxy for a member result type such as a property or field type or method return type.
         In CLR, reference types are nilable by default.
         """
-        if clrType is nil
+        if clrType is nil or clrType is sharp'typeof(void)' # C# null data vs null code return
             return .compiler.voidType
         else if clrType.isValueType
             return ClrTypeProxy(clrType)
@@ -585 +602 @@
         # the first argument is implicit in an Extension
         results = base._scanParams(paramInfos)
         return results[1:]
+        
+class MethodSig 
+    is partial
+    
+    def _scanNativeType
+        base._scanNativeType
+        _scanIsNames
+        #_scanImplements
+        #_scanNestedTypes
+        #_scanFields
+        _scanInitializers
+        #_scanProperties
+        _scanMethods
+        #_scanEvents
+        
+        # reflect on  invoke method to find signature
+        methInfo = .clrType.getMethod('Invoke', BindingFlags(Instance, Static, DeclaredOnly, Public, NonPublic))
+        if methInfo and _methOK(methInfo to !)
+            _params = _scanParams(methInfo.getParameters)
+            _returnTypeProxy = _memberTypeResultProxy(methInfo to !, methInfo.returnType) 
+        #if .clrType.isGenericType
+        #   print .name, methInfo.returnType, _params
+                
+    def _methOK( methInfo as System.Reflection.MethodInfo)  as bool
+        if methInfo.isSpecialName or methInfo.isAssembly or methInfo.isPrivate
+            return false
+        if methInfo.declaringType is not .clrType, return false
+        if  _badRelatedType(methInfo.returnType)
+            return false
+        for paramInfo in methInfo.getParameters
+            if _badRelatedType(paramInfo.parameterType)
+                return false
+        return true     

Source/Boxes.cobra

@@ -430 +430 @@
             _declsByName[ol.name] = ol
             _declsByNameCI[ol.name.toLower] = ol
 
+    def addDecl(decl as IBoxMember) is override
+        base.addDecl(decl)
+        # overridden to explicitly store methodSigs separately
+        if decl inherits MethodSig
+            base.addSig(decl)
+
     def addDeclFromOverload(decl as IBoxMember, ol as MemberOverload)
         require
             ol in .overloads
@@ -1535 +1541 @@
     The "sig" keyword fits nicely with other declaration keywords like "var" "def" and "get".
     And "sig" is a more platform neutral term should we have other non-CLI backends.
     
-    MethodSigs are only created when parsing. When reading from a DLL, delegates are merely
-    subclasses of Delegate or MulticastDelegate.
+    MethodSigs are created when parsing. When reading from a DLL, delegates are merely
+    subclasses of (class) Delegate but subclasses of MulticastDelegate are created as MethodSigs so that
+    type inference and sig matching can be done if such a MethodSig is used as a type..
     
     Note that MethodSig is a subclass of Class and therefore both a Box and an IType. Also, it will
     return true for .isDescendantOf(.compiler.delegateType).
@@ -1554 +1561 @@
         _params = params
         _returnTypeProxy = returnTypeProxy
  
+    cue init(nativeType as NativeType)
+        base.init(TokenFix.empty, TokenFix.empty, ClrTypeProxy.cobraNameForSharpBoxName(nativeType.name),
+            List<of IType>(), List<of String>(), AttributeList(), 
+            LibraryTypeProxy('System.MulticastDelegate'), List<of ITypeProxy>(), 
+            List<of ITypeProxy>(), nil)
+        _initNativeType(nativeType)
+        # below are temp placeholders until _scanNativeType runs (no params, void returned)
+        _params = List<of Param>()
+        _returnTypeProxy = TypeProxy(.compiler.voidType)
+
     get params from var
     
     get returnTypeProxy from var
@@ -1563 +1580 @@
     get resultType as IType? is override
         return .returnType
 
+    def addRefFields
+        base.addRefFields
+        .addField('params', _params)
+        .addField('returnType', _returnType)
+        
     def _bindInh
         base._bindInh
         assert _baseClass
         assert _baseClass.qualifiedName == 'System.MulticastDelegate'
         assert .parentBox or .parentNameSpace
-
+        assert not _needScanNativeType
+        
     def _bindInt
-        returnType as ITypeProxy = .returnType ? .returnTypeProxy
-        .addDecl(_makeMethod('invoke', .params.clone, returnType))
-        # dynamic type vari length param in list as placeholder for multiple params 
-        params = [Param('vParam', VariTypeIdentifier(.token, TypeIdentifier(.token, DynamicType())))]
-        .addDecl(_makeMethod('beginInvoke', params, TypeIdentifier(.token.copy('ID', 'IAsyncResult')) to ITypeProxy))
-        .addDecl(_makeMethod('endInvoke',   params, returnType ))
+        if not .isFromBinaryLibrary # If From Assembly/Library these methods have already been inserted 
+            # TODO: push these down to _ScanClrType, platform specific.
+            returnType as ITypeProxy = .returnType ? .returnTypeProxy
+            .addDecl(_makeMethod('invoke', .params.clone, returnType))
+            # dynamic type vari length param in list as placeholder for multiple params 
+            params = [Param('vParam', VariTypeIdentifier(.token, TypeIdentifier(.token, DynamicType())))]
+            .addDecl(_makeMethod('beginInvoke', params, TypeIdentifier(.token.copy('ID', 'IAsyncResult')) to ITypeProxy))
+            .addDecl(_makeMethod('endInvoke',   params, returnType ))
         base._bindInt
         for param in .params
             param.bindInt
@@ -1590 +1615 @@
         # method body just to avoid a Cobra warning during .bindImp
         m.statements.add(ThrowStmt(.token, PostCallExpr(.token, IdentifierExpr(.token, 'Exception'), List<of Expr>()))) 
         return m
+    
+    def isAssignableTo(type as IType) as bool is override
+        r = base.isAssignableTo(type)
+        if not r
+            if (nnt = type.nonNil) inherits MethodSig
+                r = .isAnonymousMatch(nnt)
+        return r
+            
+    def isAnonymousMatch(aSig as MethodSig) as bool
+        """
+        Indicate whether this methodSig is an anonymous match for the provided one.
+        An anonymous match is one that ignores the name but succeeds if the sig returnType and
+        the count, type and ordering of the parameters is the same.
+        """
+        if .isFromBinaryLibrary 
+            # if from platform Assembly/Library do (minimal) bindings on-demand  
+            if not .didBindInh, .bindInh # TODO: optimise this more
+            if not .didBindInt, .bindInt    
+        assert aSig.returnType
+        assert .returnType
+        #print '    [aSig.name] [.name] ReturnType', aSig.returnType.name, .returnType.name
+        if not _matchesType(aSig.returnType to !, .returnType to !)
+            return false
+        params = .params
+        otherParams = aSig.params
+        #print '    ParamCount',  otherParams.count, params.count
+        if otherParams.count <> params.count
+            return false
+        for i in params.count
+            #print '    param([i])',  otherParams[i].type.name, params[i].type.name, otherParams[i].type, params[i].type
+            if not _matchesType(otherParams[i].type, params[i].type)
+                return false
+            if otherParams[i].direction <> params[i].direction
+                return false
+        return true
+
+    def _matchesType(a as IType, b as IType) as bool
+        if a.nonNil inherits GenericParam or b.nonNil inherits GenericParam
+            return true
+        # The above provides a mixed blessing of matches to generic delegates (delegates with generic params) 
+        # of which in 'use'ed assemblies (System specifically) there are a bunch that match common cases. 
+        # Good for Comparable implementations, erroneous hits for pretty much every other simple signature
+        # See ScanClrType for how this is addressed.
+        return a.isAssignableTo(b) # is this sufficient?
+    
+    def toCobraSource as String
+        s = StringBuilder()
+        s.append('sig ' + .name )
+        if .params.count
+            s.append('(')
+            sep = ''
+            for p in .params
+                s.append(sep)
+                sep = ', '
+                s.append(p.name)
+                s.append(' as ')
+                s.append(p.type.name)
+            s.append(')')
+        if .returnType <> .compiler.voidType
+            s.append(' as ')
+            s.append(.returnType.name)
+        return s.toString
         
 class GenericParam inherits CobraType is partial
     """

Source/Container.cobra

@@ -25 +25 @@
         May return nil if no such member exists.
         Case-sensitive.
         """
+        
+    def sigForMethodSig(msig as MethodSig, searchHier as bool) as MethodSig?
+        """
+        Returns the first method signature of this container matching the provided signature, if searchHier is true includes
+        any inherited methodSignatures ( i.e follows inheritance chain).
+        A 'matching' signature has the same returnType, paramList size and paramList types in the same order.
+        May return nil if no such sig exists.
+        """
 # TODO:
 #       require
 #           # TODO: not .compiler.isParsing
@@ -83 +91 @@
     var _declsInOrder as List<of TMember>
     var _declsByName as Dictionary<of String, TMember>
     var _declsByNameCI as Dictionary<of String, TMember>
+    var _sigsInOrder as List<of MethodSig>
     var _docString as String
     var _isNames as IList<of String>
 
@@ -93 +102 @@
         base.init(token, name)
         _initParent(parent)
         _declsInOrder = List<of TMember>()
+        _sigsInOrder = List<of MethodSig>()
         _declsByName = Dictionary<of String, TMember>()
         _declsByNameCI = Dictionary<of String, TMember>()
         _isNames = isNames.toList
@@ -161 +171 @@
             else
                 _declsByNameCI.add(decl.name.toLower, decl)
 
+    def addSig(signat as MethodSig)         
+        _sigsInOrder.add(signat)
+
     def declForName(name as String) as TMember?
         require
             name.length
@@ -345 +358 @@
 
     def cloneCollections
         _declsInOrder = List<of TMember>(_declsInOrder)
+        _sigsInOrder  = List<of MethodSig>(_sigsInOrder)
         _declsByName = Dictionary<of String, TMember>(_declsByName)
         _declsByNameCI = Dictionary<of String, TMember>(_declsByNameCI)
-
-
+        
+    def sigForMethodSig(ms as MethodSig, searchHier as bool) as MethodSig?
+        """
+        Search inheritance tree for a MethodSig matching the given parameter. 
+        Look in this containers siglist for a matching sig, If none recursively look in parent.
+        Return first matching sig or nil if none found
+        """
+        aSig = _haveSigForMethodSig(ms)
+        if aSig
+            return aSig
+            
+        if .parent and searchHier
+            return .parent.sigForMethodSig(ms, searchHier)
+        return nil
+        
+    def _haveSigForMethodSig(ms as MethodSig) as MethodSig?
+        """Return first matching sig in this container matching the MethodSig parameter or nil if none."""
+        for aSig in _sigsInOrder
+            #print ms.name, aSig.name
+            if aSig.isAnonymousMatch(ms)
+                return aSig
+        return nil
+            
 interface IMember
     is partial
     inherits INamedNode

Source/BinaryOpExpr.cobra

@@ -295 +295 @@
                     rightName = _right.definition.name
                     .compiler.warning(this, 'Setting a parameter ("[leftName]") to a class variable ("[rightName]") is often a mistake. You may want to reverse the assignment.')
 
+        # method type inference for assignment from a ref where sig is buried in target class
+        # Needs doing after both _left and _right have been through bindImp             
+        if not .hasError and _right inherits RefExpr and _right.type inherits PassThroughType # _type not already set
+            refExp as RefExpr = _right to RefExpr
+            # form: id = ref expr - already checked in RefExpr but deferred
+            #if _left inherits IdentifierExpr 
+            #   refExp.missingSig(.compiler.curCodeMember.parentBox)
+            # form: {a.}*member = ref expr - Sig is allowed to be buried in {a.}*
+            if _left inherits DotExpr 
+                if _left.left.type inherits Box 
+                    container = _left.left.type to Box
+                    refExp.tryForLocalSig(container)
 
+
 class NumericPromoExpr inherits BinaryOpExpr is partial
 
     cue init(opToken as IToken, op as String, left as Expr, right as Expr)
@@ -367 +380 @@
                 _type = leftType
             else if cannotMix
                 .throwError('Cannot mix types [_left.type.name] and [_right.type.name] for arithmetic.')
+            else if _left.isKindOf(.compiler.delegateType)
+                _type = tpassthrough # Not really but allows catching += -= below
+    
             if _type is nil
                 sugg = 'Try finding a method that performs this function.'
                 if leftType == rightType
@@ -413 +429 @@
         base._bindImp
         # TODO: does NumericPromoExpr cover everything we need?
         # C# and other languages use += and -= on delegates and events, but Cobra does not.
-        if .left.type inherits MethodSig
-            # TODO: error
-            pass
-        else if .left.type.nonNil.isDescendantOf(.compiler.delegateType)
+        if .left.type inherits MethodSig or .left.type.nonNil.isDescendantOf(.compiler.delegateType)
             leftSource = .left.toCobraSource
             rightSource = .right.toCobraSource
             if not .right inherits RefExpr, rightSource = 'ref ' + rightSource

Source/NameSpace.cobra

@@ -264 +264 @@
         for ud in _useDirectives
             m = ud.extensionMemberFor(box, name)
             if m, return m
-        return if(_superNameSpace, _superNameSpace._extensionMemberFromUseDirectives(box, name), nil)
+        if _superNameSpace
+            m = _superNameSpace._extensionMemberFromUseDirectives(box, name)
+            if m, return m
+        return nil
+        
+    def sigForMethodSig(ms as MethodSig, searchHier as bool) as MethodSig? is override
+        """
+        Search namespace and UseDirectives for a MethodSig matching the given parameter. 
+        Return first matching sig or nil if none found.
+        """
+        if not .isUnified
+            m = _unifiedNameSpace.sigForMethodSig(ms, searchHier)
+            if m 
+                #print 'MATCH (u-ns [.name])', m.name
+                return m
+            return _sigMethodFromUseDirectives(ms)
+        else
+            asig = _haveSigForMethodSig(ms)  # from Container baseclass
+            if asig
+                #print 'MATCH (ns)', asig.name
+                return asig
+            if _superNameSpace and searchHier
+                s = _superNameSpace._sigMethodFromUseDirectives(ms)
+                if s 
+                    #print 'MATCH (super-ns)', s.name
+                    return s
+        #print 'NO-MATCH (ns [.name])', ms.name
+        return nil
 
+
+    def _sigMethodFromUseDirectives(ms as MethodSig) as MethodSig?
+        """ Look for MethodSig in namespaces referenced by the useDirectives"""
+        for ud in _useDirectives
+            #print 'USEDIR', ud.fullName
+            s = ud.sigMethodFor(ms)
+            if s 
+                #print 'MATCH (usedir [ud.fullName])', s.name
+                return s
+        if _superNameSpace
+            s = _superNameSpace._sigMethodFromUseDirectives(ms)
+            if s
+                #print 'MATCH (ud super-ns)', s.name
+                return s
+        #print 'NO-MATCH (usedirs)', ms.name
+        return nil
+            
+
     def symbolForName(name as String) as IMember?
         if not .isUnified
             x = _unifiedNameSpace.symbolForName(name)
@@ -276 +321 @@
             if members.count == 1
                 return List<of IMember>(members)[0]  # TODO: feels silly. maybe Set should have a .only method with require .count==1
             else if members.count > 1
-                membersList = List<of IMember>(members)
-                membersList.sort(do(a as IMember, b as IMember))
-                    return a.parentNameSpace.fullName.compareTo(b.parentNameSpace.fullName)
-                spaces = (for m in membersList get '"[m.parentNameSpace.fullName]"').join(', ', ' and ')
-                if .compiler and .compiler.nodeStack.peek inherits ISyntaxNode
-                    node = .compiler.nodeStack.peek
-                else
-                    node = this
-                node.throwError('Ambiguous reference "[name]" found in namespaces [spaces].')
+                _throwAmbiguousRefError(name, members)
         else
             # our decl?
             # TODO: should this come before checking our name? what does C# do?
@@ -298 +335 @@
                 if x, return x
 #/
         return nil
-
+        
+    def _throwAmbiguousRefError(name as String, members as Set<of IMember>)
+        membersList = List<of IMember>(members)
+        membersList.sort(do(a as IMember, b as IMember))
+            return a.parentNameSpace.fullName.compareTo(b.parentNameSpace.fullName)
+        spaces = (for m in membersList get '"[m.parentNameSpace.fullName]"').join(', ', ' and ')
+        if .compiler and .compiler.nodeStack.peek inherits ISyntaxNode
+            node = .compiler.nodeStack.peek
+        else
+            node = this
+        node.throwError('Ambiguous reference "[name]" found in namespaces [spaces].')
+        
     def _symbolsForNameFromUseDirectives(name as String, members as Set<of IMember>)
         """
         Populates `members` with all symbols from `use` directives that match `name`.
@@ -308 +356 @@
             if x, members.add(x)
         if _superNameSpace
             _superNameSpace._symbolsForNameFromUseDirectives(name, members)
-
+            
     def addDecl(decl as INameSpaceMember) is override
         base.addDecl(decl)
         if decl inherits NameSpace
@@ -332 +380 @@
                 pass
             else
                 _unifiedNameSpace.addDecl(decl)
+        if decl inherits MethodSig
+            base.addSig(decl)
 
     def addUseDirective(ud as UseDirective)
         _useDirectives.add(ud)
@@ -403 +453 @@
         .addField('boundNameSpace', _boundNameSpace)
 
     get boundNameSpace from var
+    get fullName from var
 
     def extensionMemberFor(box as Box, name as String) as IMember?
         require .didBindUse
@@ -411 +462 @@
     def findSymbol(name as String) as IMember?
         require .didBindUse
         return _boundNameSpace.symbolForName(name)
+
+    def sigMethodFor(ms as MethodSig) as MethodSig? 
+        require .didBindUse
+        return _boundNameSpace.sigForMethodSig(ms, true)

Tests/120-classes/320-construct-prop-set.cobra

@@ -67 +67 @@
     pro style from var
 
 
+    # This sig needs to be accessible to both Stuff and X but C# evidently 
+    # leaks this local type on assignment and evidently cobra must also.
     sig DoSomethingSig
 
     pro doSomething from var as DoSomethingSig?

Tests/320-misc-two/820-anonymous-methods-aka-closures/210-anonymous-method-assign.cobra

@@ +1 @@
+class TestAnonMethodAssign
+    
+    sig RetInt(a as int, b as int) as int
+    sig RetStr(a as int, b as int) as String
+    
+    def main is shared
+        t = [4, 7, 1, 2, 3]
+        t1=t
+        
+        # embedded closure
+        t.sort(do(a as int, b as int))
+            return a.compareTo(b)
+        assert  t == [1,2,3,4,7]
+        
+        # store closure in local var
+        c as Comparison<of int> = do(a as int, b as int)
+            return a.compareTo(b)
+        t1.sort(c)
+        assert  t1 == [1,2,3,4,7]
+
+        # this should work shouldnt it ?
+        /#c0 = do(a as int, b as int) as int
+            return a - b
+        t1.sort(c0)
+        print t1
+        print .x(c0)
+        #/
+        
+        # now try with various combinations of typing and inference
+        c1 as RetStr = do(a as int, b as int) as String
+            return '[a] - [b]'
+        assert  .xs(c1) == '10 - 5'
+        
+        # infer (and match to existing sig) variable type
+        c2 = do(a as int, b as int) as String
+            return '[a]xx - [b]xx'
+        assert c2.typeOf == RetStr
+        assert .xs(c2) == '10xx - 5xx'
+    
+        c3 = do(a as int, b as int)  #infer returnType
+            return '[a]xy - [b]xy'
+        assert c3.typeOf == RetStr
+        assert .xs(c3) == '10xy - 5xy'
+        
+    def x( m as RetInt) as int is shared
+        return m(10, 5) 
+        
+    def xs( m as RetStr) as String is shared
+        return m(10, 5) 
+        

Tests/320-misc-two/800-attributes/130-attributes-tricky-names.cobra

@@ -8 +8 @@
 with no warnings or errors.
 """
 use System.Xml
-use System.Xml.Linq
 use System.Xml.Serialization
 
 class Season has Serializable

Tests/320-misc-two/830-lambdas/310-lambda-assign.cobra

@@ +1 @@
+class LambdaAssign
+    
+    sig RetInt(a as int, b as int) as int
+    sig RetStr(a as int, b as int) as String
+    
+    def main is shared
+        t = [4, 7, 1, 2, 3]
+        t1=t
+        
+        # embedded closure
+        t.sort(do(a as int, b as int) = a.compareTo(b))
+        assert  t == [1,2,3,4,7]
+        
+        # store closure in local var
+        c as Comparison<of int> = do(a as int, b as int) = a.compareTo(b)
+        t1.sort(c)
+        assert  t1 == [1,2,3,4,7]
+
+        # this should work shouldnt it ?
+        # evidently not
+        /#c0 = do(a as int, b as int) = a - b
+        t1.sort(c0)
+        print t1
+        print .x(c0)
+        #/
+        
+        # now try with various combinations of typing and inference
+        c1 as RetStr = do(a as int, b as int) = '[a] - [b]'
+        assert  .xs(c1) == '10 - 5'
+        
+        c2 = do(a as int, b as int) = '[a]xx - [b]xx'
+        assert c2.typeOf == RetStr
+        assert .xs(c2) == '10xx - 5xx'
+    
+        #infer returnType
+        c3 = do(a as int, b as int)  = 10*a -b
+        assert c3.typeOf == RetInt
+        assert .x(c3) == 95
+        
+    def x( m as RetInt) as int is shared
+        return m(10, 5) 
+        
+    def xs( m as RetStr) as String is shared
+        return m(10, 5) 
+        

Tests/220-delegates-etc/100-delegates/176-sig-infer-local-common.cobra

@@ +1 @@
+# Support weird C# non inheritance-scope Sig type inference
+# Forward reference to sig in Target class
+#   passing ref typed for Sig dcl in target class
+#   passing init code to run in context of other class
+#   setting property with Sig type declared in other class
+
+class X
+
+    shared
+    
+        var _counter = 0
+        
+        get counter from var
+    
+        def incCounter
+            _counter += 1
+
+        def main
+            s = Stuff(ref .incCounter)  # pass a method reference to ctor
+            assert .counter == 0
+            ds = s.doSomething
+            ds()
+            assert .counter == 1
+            
+            s1 = Stuff(doSomething = ref .incCounter)  # pass nowt, init prop to a method reference
+            _counter = 10
+            assert .counter == 10
+            ds = s1.doSomething
+            ds()
+            assert .counter == 11
+
+            
+ 
+            s2 = Stuff()  # pass nowt
+            s2.doSomething = ref .incCounter    #init prop to a method reference
+            # This is OK - and a damn sight clearer
+            #s2.doSomething = Stuff.DoSomethingSig(ref .incCounter) 
+            _counter = 20
+            assert .counter == 20
+            ds = s2.doSomething
+            ds()
+            assert .counter == 21
+            
+
+class Stuff
+
+    sig DoSomethingSig
+
+    pro doSomething from var as DoSomethingSig?
+    
+    cue init
+        base.init
+        
+    cue init(ds as DoSomethingSig)
+        base.init
+        .doSomething = ds

Tests/220-delegates-etc/100-delegates/172-infer-ref-type-no-sig.cobra

@@ +1 @@
+# Ref type inference and methodSig auto generation and injection
+class MyType
+    pass
+
+class AutoGenMethodSig
+    #sig MethNoArg
+
+    # non simple signature that doesnt collide with any generic System delegates
+    # e.g System.Action (one arg, no return), 
+    #     System.EventHandler(2 args, no return),
+    #     System.Comparison(2 args, int return)
+    def methUnknown(r as MyType, r1 as MyType) as MyType
+        return r
+    
+    def methUnknown2(r as MyType, r1 as MyType) as MyType
+        return r1
+    
+    def methAction0
+        pass
+        
+    def methAction(r as MyType)
+        pass
+        
+    def main is shared
+        c = AutoGenMethodSig()
+            
+        meUnk = ref c.methUnknown # .warning. No signature matching
+        assert meUnk.typeOf == SigFor_methUnknown # autogen Sig and inserted
+    
+        meUnk2 = ref c.methUnknown2
+        assert meUnk2.typeOf == SigFor_methUnknown # found autogen Sig
+        
+        # was matchiung to CrossAppDomainDelegate
+        meAct0 = ref c.methAction0   # .warning. No signature matching
+        assert meAct0.typeOf == SigFor_methAction0
+        #assert meAct0.typeOf == MethNoArg
+        
+        # was matching to Converter<to,>
+        meAct1 = ref c.methAction # .warning. No signature matching
+        print meAct1
+        

Tests/220-delegates-etc/100-delegates/178-sig-infer-local-err.cobra

@@ +1 @@
+# Local variable using target local Sig - if not explicitly typed and 
+# no matching Sig in scope cobra creates default one 
+# BUT C# cannot/willnot then implicitly (or explicitly) convert fm 
+# compatible Sig to target local Sig
+class X
+
+    shared
+    
+        var _counter = 0
+        
+        get counter from var
+    
+        def incCounter
+            _counter += 1
+
+        def main
+        
+            s3 = Stuff()  # pass nowt
+            x = ref .incCounter # .warning. no signature matching
+            s3.doSomething = x  # .error. cannot implicitly convert
+            _counter = 22
+            assert .counter == 22
+            ds = s3.doSomething
+            ds()
+            assert .counter == 23
+
+class Stuff
+
+    sig DoSomethingSig
+
+    pro doSomething from var as DoSomethingSig?
+    
+    cue init
+        base.init
+        
+    cue init(ds as DoSomethingSig)
+        base.init
+        .doSomething = ds

Tests/220-delegates-etc/100-delegates/170-infer-ref-type.cobra

@@ +1 @@
+# Test Ref type inference and matching autogenerated ref sig
+# to App or system MethodSigs
+
+sig SigForMethOuter(s as String)
+
+class RefType
+    
+    sig SigForMethInner(a as int)
+    sig SigForDynamic(a as dynamic?) as bool
+    
+    def meth(a as int)
+        print a
+    
+    def methOuter(s as String)
+        print s
+        
+    def methUnknown(r)
+        pass
+    
+    def methConcDy(a as Object?) as bool
+        return false
+    
+    # EventHandler 
+    def handleEvent( src as Object, args as EventArgs)
+        pass
+        
+    # ResolveEventHandler 
+    def handleResolveEvent(sender as Object, args as ResolveEventArgs) as System.Reflection.Assembly?
+        return System.Reflection.Assembly.getExecutingAssembly
+
+    def chkMySig
+        me = ref .meth
+        assert  me.typeOf == SigForMethInner
+        
+    def main is shared
+        c = RefType()
+        c.chkMySig
+        
+        me = ref c.meth  # auto type me
+        assert me.typeOf == SigForMethInner
+    
+        me1 = ref c.methOuter
+        assert me1.typeOf == SigForMethOuter
+        
+        
+        # equivalence Object? and dynamic arg
+        mdy = ref c.methConcDy
+        assert mdy.typeOf == SigForDynamic
+    
+        # match to System MethodSigs (from use assembly/dll)
+        meh = ref c.handleEvent
+        assert meh.typeOf == System.EventHandler
+    
+        meres  = ref c.handleResolveEvent
+        assert meres.typeOf == System.ResolveEventHandler
+
+        # ticket 140
+        for x in [ref c.meth, ref c.meth]
+            assert x.typeOf == SigForMethInner
+    
+        for y in [ref c.methOuter, ref c.methOuter]
+            assert y.typeOf == SigForMethOuter
+            
+        #meUnk = ref c.methUnknown
+        #print 'me2', meUnk
+
+            

Tests/220-delegates-etc/100-delegates/177-sig-infer-local.cobra

@@ +1 @@
+# local var using target local Sig - needs to be explicitly types
+class X
+
+    shared
+    
+        var _counter = 0
+        
+        get counter from var
+    
+        def incCounter
+            _counter += 1
+
+        def main
+        
+            s3 = Stuff()  # pass nowt
+            x as Stuff.DoSomethingSig = ref .incCounter #init local to a non scoped Sig method reference
+            #x = Stuff.DoSomethingSig(ref .incCounter) #init local to a non scoped Sig method reference
+            s3.doSomething = x  
+            _counter = 22
+            assert .counter == 22
+            ds = s3.doSomething
+            ds()
+            assert .counter == 23
+            
+        
+
+class Stuff
+
+    sig DoSomethingSig
+
+    pro doSomething from var as DoSomethingSig?
+    
+    cue init
+        base.init
+        
+    cue init(ds as DoSomethingSig)
+        base.init
+        .doSomething = ds