Ticket #226: big-or-complex.patch

Source/Members.cobra

@@ -1483 +1483 @@
         else
             members = .members
 
-        for member in members
-            score = -1000
-            if member.params.count == args.count
-                score = 0
-                if member inherits Method and (member to Method).genericParams.count > 0, score += 1
-                for i, param in member.params.numbered
-                    arg = args[i]
-                    if strictBindChecking and not arg.didBindImp
-                        trace arg
-                        trace arg.hasError
-                    if strictBindChecking and (arg.type == param.type or arg.type == param.type.nonNil)
-                        score += 20
-                    else if strictBindChecking and arg.canBeAssignedTo(param.type)
-                        score += 10
-                    else if strictBindChecking and arg.type.nonNil.isAssignableTo(param.type) 
-                        # Cobra's code and data flow analysis sometimes leaves us with a nilable type that's not actually nil anymore
-                        # due to an assignment, possibly wrapped in an if statement. Eventually this will be corrected, but for now
-                        # compensate here.
-                        score += 1
-                    else if not strictBindChecking
-                        if arg.type is not nil
-                            if arg.type == param.type
-                                score += 20
-                            else if arg.type.isDynamic
-                                score += 10
-                        else
-                            score -= 100
-                    else
-                        score -= 100
-            # print 'candidate:', score, member.name, member.serialNum, Utils.join(', ', (for param in member.params get param.type.name))
-            candidates.add([score, member])
+        _calcMembersScore(members, args, strictBindChecking, candidates)
             
         maxScore = -10_000
         winner = nil to BoxMember?
@@ -1559 +1529 @@
         assert winner
         return winner to !
     
+    def _calcMembersScore(members as List<of BoxMember>, args as List<of Expr>, strictBindChecking as bool, candidates)
+        for member in members
+            score = -1000
+            if member.params.count == args.count
+                score = 0
+                if member inherits Method and (member to Method).genericParams.count > 0, score += 1
+                for i, param in member.params.numbered
+                    arg = args[i]
+                    if strictBindChecking and not arg.didBindImp
+                        trace arg
+                        trace arg.hasError
+                    if strictBindChecking and (arg.type == param.type or arg.type == param.type.nonNil)
+                        score += 20
+                    else if strictBindChecking and arg.canBeAssignedTo(param.type)
+                        score += 10
+                    else if strictBindChecking and arg.type.nonNil.isAssignableTo(param.type) 
+                        # Cobra's code and data flow analysis sometimes leaves us with a nilable type that's not actually nil anymore
+                        # due to an assignment, possibly wrapped in an if statement. Eventually this will be corrected, but for now
+                        # compensate here.
+                        score += 1
+                    else if not strictBindChecking
+                        if arg.type is not nil
+                            if arg.type == param.type
+                                score += 20
+                            else if arg.type.isDynamic
+                                score += 10
+                        else
+                            score -= 100
+                    else
+                        score -= 100
+            # print 'candidate:', score, member.name, member.serialNum, Utils.join(', ', (for param in member.params get param.type.name))
+            candidates.add([score, member])
+
     def _bindInt is override
         base._bindInt
         # sanity check that members all have the right name

Source/TypeProxies.cobra

@@ -168 +168 @@
         
         # Must return the Cobra primitive types in place of System.Boolean, System.Char, System.Int16, etc.
         # because it's the primitives that are used all over the compiler.
-
         clrPrimitiveToIType = .compiler.clrPrimitiveToITypeCache
         if clrPrimitiveToIType is nil or clrPrimitiveToIType.count == 0
-            clrPrimitiveToIType = Dictionary<of System.Type, IType>()
-            for bt in .compiler.basicTypes
-                if bt.systemAliasProxy
-                    key = (.compiler.nativeType((bt.systemAliasProxy to LibraryTypeProxy).qualifiedName) to ClrNativeType).clrType # TODO: cleanup
-                    clrPrimitiveToIType[key] = bt
-            assert clrPrimitiveToIType.count == 0 or clrPrimitiveToIType.count > 9
+            clrPrimitiveToIType = _makePrimitiveTypesDict
         basicType as IType?
         if clrPrimitiveToIType.tryGetValue(clrType, out basicType)
             return basicType to !
@@ -211 +205 @@
         if clrType.isGenericParameter
             return GenericParam(ClrNativeType(clrType))
 
-        # compute type name
-        typeName = clrType.name
-        if '`' in typeName
-            # generic like IComparable`1
-            assert r'[' not in typeName
-            typeName = .cobraNameForSharpBoxName(typeName)
-        else if typeName[typeName.length-1].isLetterOrDigit
-            pass
-        else
-            .throwError('Cannot locate CLR type "[clrType]".')
-
-        # compute namespace
+        typeName = _computeTypeName(clrType)
         missing = false
-        nameParts = clrType.namespace.split(c'.')
-        member = .compiler.globalNS.symbolForName(nameParts[0])
-        if member inherits NameSpace, curNS = member
-        else, missing = true
-        if not missing
-            i = 1
-            while i < nameParts.length
-                namePart = nameParts[i]
-                possible = curNS.declForName(namePart)
-                if possible is nil
-                    missing = true
-                    break
-                else if possible inherits NameSpace
-                    curNS = possible
-                else
-                    .throwError('Found "[namePart]" at component [i+1] of CLR type "[clrType.fullName]", but it is a [possible.englishName].')
-                i += 1
-
+        curNS = _computeNameSpace(clrType, level, out missing)
         if missing
             # since the CLR type exists, but cannot be located in our namespaces,
             # it must be pulled from a dependent DLL that was not directly referenced
-            
             # but maybe it was already attempted
             if level > 0
                 .throwError('Cannot read CLR type "[clrType.fullName]" or its assembly "[clrType.assembly]". Please report to the Cobra discussion forums (http://cobra-language.com/).')
 
             (.compiler to dynamic).readAssembly(clrType.assembly)
-            return _realTypeWithoutCache(clrType, level+1)  # recurse. guard is just above.
+            return _realTypeWithoutCache(clrType, level+1) # recurse. guard is just above.
 
         # return namespace member
-        member = curNS.declForName(typeName)
+        member as IMember? = curNS.declForName(typeName)
         if member inherits IType
             if member inherits Box
                 if clrType.isGenericType and not clrType.isGenericTypeDefinition
                     # So we have something like ICollection<of KeyValuePair<of TKey,TValue>> which is all CLR types.
                     # We need the Cobra types of those args so we can construct the Cobra type from the generic cobra type
                     # otherwise, we would just end up returning the generic definition.
-                    args = List<of IType>()
-                    for genArg in clrType.getGenericArguments
-                        args.add(_realTypeWithCache(genArg))
-                    if member.qualifiedName == 'System.Nullable<of>'
-                        assert args.count == 1
-                        member = .typeProvider.nilableType(args[0])
-                    else
-                        member = (member to Box).constructedTypeFor(args)
+                    member = _typeForArgsOfGeneric(clrType, member)
             return member
         else
             msg = 'Cannot locate CLR type "[clrType]".'
@@ -284 +242 @@
                 .throwError(msg)
         return .compiler.intType  # CC: to make C# code gen happy.
 
+    def _makePrimitiveTypesDict as Dictionary<of System.Type, IType>
+        clrPrimitiveToIType = Dictionary<of System.Type, IType>()
+        for bt in .compiler.basicTypes
+            if bt.systemAliasProxy
+                key = (.compiler.nativeType((bt.systemAliasProxy to LibraryTypeProxy).qualifiedName) to ClrNativeType).clrType # TODO: cleanup
+                clrPrimitiveToIType[key] = bt
+        assert clrPrimitiveToIType.count == 0 or clrPrimitiveToIType.count > 9
+        return clrPrimitiveToIType
+
+    def _computeTypeName(clrType as Type) as String
+        typeName = clrType.name
+        if '`' in typeName
+            # generic like IComparable`1
+            assert r'[' not in typeName
+            typeName = .cobraNameForSharpBoxName(typeName)
+        else if typeName[typeName.length-1].isLetterOrDigit
+            pass
+        else
+            .throwError('Cannot locate CLR type "[clrType]".')
+        return typeName
+
+    def _computeNameSpace(clrType as Type, level as int, missing as out bool) as NameSpace
+        missing = false
+        nameParts = clrType.namespace.split(c'.')
+        member = .compiler.globalNS.symbolForName(nameParts[0])
+        if member inherits NameSpace, curNS = member
+        else, missing = true
+        if not missing
+            i = 1
+            while i < nameParts.length
+                namePart = nameParts[i]
+                possible = curNS.declForName(namePart)
+                if possible is nil
+                    missing = true
+                    break
+                else if possible inherits NameSpace
+                    curNS = possible
+                else
+                    .throwError('Found "[namePart]" at component [i+1] of CLR type "[clrType.fullName]", but it is a [possible.englishName].')
+                i += 1
+        return curNS    
+
+    def _typeForArgsOfGeneric(clrType as Type, member as IType) as IType
+        args = List<of IType>()
+        for genArg in clrType.getGenericArguments
+            args.add(_realTypeWithCache(genArg))
+        boxMember = member to Box
+        if boxMember.qualifiedName == 'System.Nullable<of>'
+            assert args.count == 1
+            member = .typeProvider.nilableType(args[0])
+        else
+            member = boxMember.constructedTypeFor(args)
+        return member   
+
     def _hack(clrType as Type) as IType
         if clrType.isInterface
             return ClrTypeProxy(sharp'typeof(System.ICloneable)').realType

Source/BackEndClr/SharpGenerator.cobra

@@ -135 +135 @@
             .modules.count
         body
             v, options = .verbosity, .options
-
             optChar = if(.platform==PlatformEnum.Microsoft, '/', '-')  # option prefix character
 
             # exe names
@@ -184 +183 @@
                 # CS1718: A comparison made to same variable.
 
             if .mainMethodTypeName <> '', backEndOptions.add('[optChar]main:[.mainMethodTypeName]')
-            
             backEndOptions.addRange(extraCscOptions)
 
             sharpArgs = .options.getDefault('native-compiler-args', List<of String>()) to List<of String>
@@ -204 +202 @@
             backEndOptions.add('-lib:[libPath]')
 
             # Passing -pkg: to the C# compiler seems unnecessary.
-            # Compiler.refsForPackage already gets the .dll refs and
-            # including this was reported as a problem at
-            # http://cobra-language.com/forums/viewtopic.php?f=4&t=263
-            # 2008-12 / 2009-01
+            # Compiler.refsForPackage already gets the .dll refs and including this was reported at
+            # http://cobra-language.com/forums/viewtopic.php?f=4&t=263  2008-12 / 2009-01
             # for pkgName in .options.getStringList('pkg')
             #   backEndOptions.add('-pkg:[pkgName]')
 

Source/Statements.cobra

@@ -686 +686 @@
                 left = cond.left
                 if left inherits IdentifierExpr
                     leftVar = left.namedDefinition
-                    if leftVar inherits IVar  # if-inherits smarts only work on variables
-                        # if x inherits Y ...
-                        if (right = cond.right) inherits IPotentialTypeExpr
-                            assert right.potentialType
-                            leftVar.ifInheritsStack.push(right.potentialType to !)
-                        else
-                            throw FallThroughException(right)
-                        ifInherits = true
-                        _trueStmts.setIfInherits(leftVar, leftVar.ifInheritsStack.peek)
+                    ifInherits = _ivarIfInherits(cond, leftVar)
+                    #if leftVar inherits IVar  # if-inherits smarts only work on variables
+                    #   # if x inherits Y ...
+                    #   if (right = cond.right) inherits IPotentialTypeExpr
+                    #       assert right.potentialType
+                    #       leftVar.ifInheritsStack.push(right.potentialType to !)
+                    #   else
+                    #       throw FallThroughException(right)
+                    #   ifInherits = true
+                    #   _trueStmts.setIfInherits(leftVar, leftVar.ifInheritsStack.peek)
                 else if left inherits AssignExpr
                     if left.left inherits IdentifierExpr
                         leftVar = left.left.definition
-                        if leftVar inherits IVar
-                            # if (x = expr) inherits Y ...
-                            if (right = cond.right) inherits IPotentialTypeExpr
-                                leftVar.ifInheritsStack.push(right.potentialType to !)
-                            else
-                                throw FallThroughException(right)
-                            ifInherits = true
-                            _trueStmts.setIfInherits(leftVar, leftVar.ifInheritsStack.peek)
+                        ifInherits = _ivarIfInherits(cond, leftVar)
+                        #if leftVar inherits IVar
+                        #   # if (x = expr) inherits Y ...
+                        #   if (right = cond.right) inherits IPotentialTypeExpr
+                        #       leftVar.ifInheritsStack.push(right.potentialType to !)
+                        #   else
+                        #       throw FallThroughException(right)
+                        #   ifInherits = true
+                        #   _trueStmts.setIfInherits(leftVar, leftVar.ifInheritsStack.peek)
             if not ifInherits
                 # check for an if-not-nil
                 if cond inherits TruthExpr
@@ -755 +757 @@
             _falseStmts.parent = this
             _falseStmts.bindImp
 
+    def _ivarIfInherits(cond as InheritsExpr, leftVar as INamedNode?) as bool
+        ifInherits = false
+        if leftVar inherits IVar  # if-inherits smarts only work on variables
+            # if x inherits Y ...
+            if (right = cond.right) inherits IPotentialTypeExpr
+                assert right.potentialType
+                leftVar.ifInheritsStack.push(right.potentialType to !)
+            else
+                throw FallThroughException(right)
+            ifInherits = true
+            _trueStmts.setIfInherits(leftVar, leftVar.ifInheritsStack.peek)
+        return ifInherits   
+
     def doNotPopIfInheritsStack
         _doNotPopIfInheritsStack = true
 

Source/Compiler.cobra

@@ -812 +812 @@
             if .referenceVerbosity, print '[fle] in _loadReference("[reference]")'
             return false
 
+    sig RVPrintStringSig( s as String)
+            
     def __loadReference(reference as String) as bool
         require
             reference.endsWith('.dll') or reference.endsWith('.exe')
@@ -821 +823 @@
             not result implies .loadedReferences.count == old .loadedReferences.count
         body
             rv = .referenceVerbosity
+            rvPrint as RVPrintStringSig = ref _rvNull
+            if rv, rvPrint = ref _rvPrint
             assert not (reference.startsWith('-r') and '-r' in reference[2:])
             if false
                 # Does not work on Novell Mono. See notes above.
@@ -829 +833 @@
             else
                 if File.exists(reference)
                     # try current directory
-                    if rv, '"[reference]" found as file. Will Assembly.loadFrom().'
+                    rvPrint('"[reference]" found as file. Will Assembly.loadFrom().')
                     referredAss = Assembly.loadFrom(reference)
-                    if rv, 'Assembly.loadFrom() returned: [CobraCore.toTechString(referredAss)]'
+                    rvPrint('Assembly.loadFrom() returned: [CobraCore.toTechString(referredAss)]')
                 else
                     # TODO: the problem with -lib: in both Cobra and C# is that it has no effect on runtime,
                     # you must still register the DLLs in the GAC or copy them into the same dir as the .exe
                     # because the -lib: paths are not passed into executable.
                     # So should Cobra copy the .dll's into the target directory (if their paths are not in MONO_PATH)?
-                    if rv, print 'File does not exist.'
+                    rvPrint('File does not exist.')
                     searchPaths = .options.getDefault('library-directory', List<of String>()) to List<of String>
                     # TODO: ?: searchPaths.add(Path.getDirectoryName(Assembly.getExecutingAssembly.location))  # try Cobra's directory - also should be added to .options.'library-directory' not to a local var
                     found = false
                     for searchPath in searchPaths
-                        if rv, 'Checking lib path: "[searchPath]"'
+                        rvPrint('Checking lib path: "[searchPath]"')
                         combinedPath = Path.combine(searchPath, reference)
                         if File.exists(combinedPath)
-                            if rv, '"[reference]" found as file. Will Assembly.loadFrom().'
+                            rvPrint('"[reference]" found as file. Will Assembly.loadFrom().')
                             referredAss = Assembly.loadFrom(combinedPath)
-                            if rv, 'Assembly.loadFrom() returned: [CobraCore.toTechString(referredAss)]'
+                            rvPrint('Assembly.loadFrom() returned: [CobraCore.toTechString(referredAss)]')
                             found = true
                             break
                     if rv
@@ -858 +862 @@
                     if not found
                         # try system wide (GAC)
                         if reference.endsWith('.dll'), reference = reference[:-4]
-                        if rv, print 'Will load with partial name "[reference]"'
+                        rvPrint('Will load with partial name "[reference]"')
                         referredAss = Utils.loadWithPartialName(reference)
-                        if rv, print 'Load with partial name returned: [CobraCore.toTechString(referredAss)]'
+                        rvPrint( 'Load with partial name returned: [CobraCore.toTechString(referredAss)]')
                         if referredAss is nil, return false
                         # 2009-08-03 CE: Removed this code:
                         # reference = referredAss.location
@@ -885 +889 @@
                                 print '<< Loading dependency: [dependency]'
                         else
                             .loadAssembly(dependency)
-                if rv, 'Will read assembly: [referredAss]'
+                rvPrint('Will read assembly: [referredAss]')
                 try
                     .readAssembly(referredAss, reference <> 'Cobra.Lang.dll')
                 catch readExc as Exception
-                    if rv, print 'Caught exception during read assembly: [readExc]'
+                    rvPrint('Caught exception during read assembly: [readExc]')
                     throw
-                if rv, 'Did read assembly: [referredAss]'
+                rvPrint('Did read assembly: [referredAss]')
                 # reassert the preconditions. there have been bugs in the past
                 assert reference.endsWith('.dll') or reference.endsWith('.exe')
                 assert reference not in ['.dll', '.exe']
                 .loadedReferences.add(reference)
-                if rv, 'Returning true for __loadReference("[reference]").'
+                rvPrint('Returning true for __loadReference("[reference]").')
                 return true
             else
-                if rv, 'Returning false for __loadReference("[reference]").'
+                rvPrint('Returning false for __loadReference("[reference]").')
                 return false
 
+    def _rvPrint(s as String)
+        print s
+
+    def _rvNull(s as String)
+        pass
+        
     var _didLoadAssemblies = Set<of String>()
 
     def loadAssembly(assName as AssemblyName)

Source/BinaryOpExpr.cobra

@@ -320 +320 @@
                     _type = .compiler.numberType
                 else
                     _type = tgcd
-            else if rightType.isDescendantOf(tdecimal)
-                _type = tdecimal
-            else if rightType.isDescendantOf(tfloat)
-                _type = tgcd
+            else
+                cannotMix = _ifRightTypeThen(tdecimal, tdecimal, tfloat, tgcd)
+            #else if rightType.isDescendantOf(tdecimal)
+            #   _type = tdecimal
+            #else if rightType.isDescendantOf(tfloat)
+            #   _type = tgcd
         else if leftType.isDescendantOf(tdecimal)
-            if rightType.isDescendantOf(tdecimal)
-                _type = tdecimal
-            else if rightType.isDescendantOf(tint)
-                _type = tdecimal
-            else if rightType.isDescendantOf(tfloat)
-                cannotMix = true
-            else
-                cannotMix = true
+            cannotMix = _ifRightTypeThen(tdecimal, tdecimal, tint, tdecimal)
+            #if rightType.isDescendantOf(tdecimal)
+            #   _type = tdecimal
+            #else if rightType.isDescendantOf(tint)
+            #   _type = tdecimal
+            #else if rightType.isDescendantOf(tfloat)
+            #   cannotMix = true
+            #else
+            #   cannotMix = true
         else if leftType.isDescendantOf(tfloat)
-            if rightType.isDescendantOf(tfloat)
-                _type = tgcd
-            else if rightType.isDescendantOf(tint)
-                _type = tgcd
-            else if rightType.isDescendantOf(tdecimal)
-                cannotMix = true
-            else
-                cannotMix = true
+            cannotMix = _ifRightTypeThen(tfloat, tgcd, tint, tgcd)
+            #if rightType.isDescendantOf(tfloat)
+            #   _type = tgcd
+            #else if rightType.isDescendantOf(tint)
+            #   _type = tgcd
+            #else if rightType.isDescendantOf(tdecimal)
+            #   cannotMix = true
+            #else
+            #   cannotMix = true
         else if leftType.isDescendantOf(tstring)
-            if rightType.isDescendantOf(tstring)
-                _type = tstring
-            else
-                cannotMix = true
+            cannotMix = _ifRightTypeThen(tstring, tstring)
+            #if rightType.isDescendantOf(tstring)
+            #   _type = tstring
+            #else
+            #   cannotMix = true
         else if leftType inherits Box
             if leftType.isGeneric and leftType.isDescendantOf(.compiler.collectionOfType.constructedTypeFor([leftType.genericParams[0]]))
                 if leftType.genericParams.count > 1
@@ -385 +390 @@
                     .throwError('Cannot apply [_op] to [leftType.name]. [sugg]')
                 else
                     .throwError('Cannot apply [_op] to [leftType.name] and [rightType.name]. [sugg]')
+
+    def _ifRightTypeThen(ifThenPairs as vari IType) as bool
+        rightType = _right.type.nonNil
+        n =0
+        while n < ifThenPairs.length
+            matchType = ifThenPairs[n]
+            resultType = ifThenPairs[n+1]
+            n += 2
+            if rightType.isDescendantOf(matchType)
+                _type = resultType
+                return false
+        return true     
+                        
     
 
 class AugAssignMathExpr inherits NumericPromoExpr is partial

Source/CobraParser.cobra

@@ -584 +584 @@
                     .genericConstraints(token, genericParams)
                 on 'INHERITS'
                     if .optional('INHERITS')
-                        expectComma = false
-                        while true
-                            if expectComma
-                                if .peek.isKeyword, break
-                                .expect('COMMA')
-                            inheritsProxies.add(.typeId)
-                            expectComma = true
-                            if .peek.which == 'EOL'
-                                .grab
-                                break
-                            else if .peek.isKeyword
-                                break
+                        _commaSepTypes(inheritsProxies)
                 on 'IMPLEMENTS'
                     if .optional('IMPLEMENTS')
-                        # TODO: use a nested def to eliminate duplication with on 'INHERITS' just above
-                        expectComma = false
-                        while true
-                            if expectComma
-                                if .peek.isKeyword, break
-                                .expect('COMMA')
-                            implementsProxies.add(.typeId)
-                            expectComma = true
-                            if .peek.which == 'EOL'
-                                .grab
-                                break
-                            else if .peek.isKeyword
-                                break
+                        _commaSepTypes(implementsProxies)
                 on 'ADDS'
                     if .optional('ADDS')
-                        expectComma = false
-                        while true
-                            if expectComma
-                                if .peek.isKeyword, break
-                                .expect('COMMA')
-                            addsProxies.add(.typeId)
-                            expectComma = true
-                            if .peek.which == 'EOL'
-                                .grab
-                                break
-                            else if .peek.isKeyword
-                                break
+                        _commaSepTypes(addsProxies)
                 else
                     isDone = true
             if last.isOneOf('EOL.INDENT.'), continue
@@ -635 +601 @@
         if not didIndent, .indent
         return TypeSpecs(isNames, attribs, inheritsProxies, implementsProxies, addsProxies)
 
+    def _commaSepTypes(proxies as List<of ITypeProxy>)
+        expectComma = false
+        while true
+            if expectComma
+                if .peek.isKeyword, break
+                .expect('COMMA')
+            proxies.add(.typeId)
+            expectComma = true
+            if .peek.which == 'EOL'
+                .grab
+                break
+            else if .peek.isKeyword
+                break
+
     def endOfTypeSpecClause
         """
         Ends a type clause on EOL or a keyword.
@@ -1343 +1323 @@
         opener = .grab to !
         if not opener.which.isOneOf('ID.OPEN_CALL.OPEN_GENERIC.') and not opener.isKeyword
             .throwError('Encountered [opener.which] when expecting an identifier.')
-        if opener.which == 'OPEN_GENERIC'
-            genericParams = .declGenericParams(opener)
-        else
-            genericParams = List<of GenericParam>()
+        genericParams = _methodGenericParams(opener)
+
         name = opener.value to String
         curBox = .curBox
         if name == curBox.name or name.capitalized == curBox.name
             .throwError('Method names cannot be the same as their enclosing [curBox.englishName]. Use `cue init` for creating an initializer/constructor or choose another name.')  # TODO list the enclosing types location
 
-        unnecessary = false
-        if opener.which == 'OPEN_CALL'
-            params = .paramDecls(/#skipParen=#/true)
-            if params.count == 0, unnecessary = true
-        else if opener.which == 'OPEN_GENERIC'
-            if .optional('LPAREN')
-                params = .paramDecls(/#skipParen=#/true)
-                if params.count == 0, unnecessary = true
-            else
-                params = List<of Param>()
-        else if opener.which == 'ID'  and  .optional('LPAREN')
-            # def id (... - misplaced space after name  
-            .throwError('Misplaced space between method name and opening brace "("') 
-        else
-            params = List<of Param>()
-        if unnecessary
-            _warning(opener, 'Unnecessary parentheses. You can remove them.')
+        params = _methodParams(opener)
+        returnType = _methodReturnType
 
-        if .optional('AS')
-            returnType = .typeId to ITypeProxy?
-        else
-            returnType = _typeProvider.voidType
-        assert returnType
-
         isNames = List<of String>(_isNamesStack)
         attribs = AttributeList()
         implementsType = nil to ITypeProxy?
-
         method as AbstractMethod?
 
         # Rules:
@@ -1426 +1382 @@
             encountered.add(last)
         assert .last.which.isOneOf('EOL.INDENT.')
 
-        if _spaceAgnosticIndentLevel
-            sail = _spaceAgnosticIndentLevel
-            if sail > 0, _spaceAgnosticIndentLevel -= 1  # for missing indent
-            if sail < 0, _spaceAgnosticIndentLevel += 1  # for missing dedent
-            _finishSpaceAgnostic
-            if sail > 0
-                nothingMore = false  # TODO: feels wrong
-            else
-                nothingMore = .last.which == 'INDENT' and .peek.which <> 'INDENT'  # _spaceAgnosticIndentLevel == 0
-        else
-            nothingMore = not didIndent and .last.which == 'EOL'
-
+        nothingMore = _endMethodDecl(didIndent)
         docString = .docString
         if token.which == 'CUE' and name == 'init'
-            if curBox inherits Interface
-                .throwError('Cannot declare an initializer for an interface.')
-            if returnType is not .typeProvider.voidType
-                .throwError('Cannot declare a return type for an initializer.')
-            if implementsType
-                .throwError('Cannot specify `implements` for an initializer.')
+            _verifyInitializer(returnType, implementsType)
             method = Initializer(token, opener, .curBox, params, isNames, attribs, docString)
         else
             method = Method(token, opener, .curBox, name, .makeList<of IType>(genericParams), params, returnType, implementsType, isNames, attribs, docString)
@@ -1455 +1395 @@
         else
             .statementsFor(method)
 
+        _verifyMethodStatements(method to !, isNames, curBox)
+        assert method
+        overload = _overloadIfNeeded(method.token, curBox, method.name)  # also checks for various errors
+        if overload
+            overload.addMember(method to !)
+            return nil
+        return method
+
+    #Helper for declareMethod; get List of GenericParam or empty GenericParam List      
+    def _methodGenericParams(opener as IToken) as List<of GenericParam>
+        if opener.which == 'OPEN_GENERIC'
+            genericParams = .declGenericParams(opener)
+        else
+            genericParams = List<of GenericParam>()
+        return genericParams    
+        
+    #Helper for declareMethod; return declared method returnType or voidType
+    def _methodReturnType as ITypeProxy
+        if .optional('AS')
+            returnType = .typeId to ITypeProxy?
+        else
+            returnType = _typeProvider.voidType
+        assert returnType
+        return returnType to !
+
+    #Helper for declareMethod; get List of Param or empty Param List        
+    def _methodParams(opener as IToken) as List<of Param>       
+        unnecessary = false
+        if opener.which == 'OPEN_CALL'
+            params = .paramDecls(/#skipParen=#/true)
+            if params.count == 0, unnecessary = true
+        else if opener.which == 'OPEN_GENERIC'
+            if .optional('LPAREN')
+                params = .paramDecls(/#skipParen=#/true)
+                if params.count == 0, unnecessary = true
+            else
+                params = List<of Param>()
+        else if opener.which == 'ID'  and  .optional('LPAREN')
+            # def id (... - misplaced space after name  
+            .throwError('Misplaced space between method name and opening brace "("') 
+        else
+            params = List<of Param>()
+        if unnecessary
+            _warning(opener, 'Unnecessary parentheses. You can remove them.')
+        return params   
+
+    #Helper for declareMethod; Error checks on statements
+    def _verifyMethodStatements(method as AbstractMethod, isNames as List<of String>, curBox as Box)
         if method.statements.count
             if 'abstract' in isNames
                 .throwError('Cannot have statements for an abstract method.')
@@ -1464 +1452 @@
             if not 'abstract' in isNames and not curBox inherits Interface
                 .throwError('Missing statements. Use "pass" or other statements.')
 
-        assert method
-        overload = _overloadIfNeeded(method.token, curBox, method.name)  # also checks for various errors
-        if overload
-            overload.addMember(method to !)
-            return nil
+    #Helper for declareMethod; slurp up indentation and indicate if end of declaration
+    def _endMethodDecl(didIndent as bool) as bool   
+        if _spaceAgnosticIndentLevel
+            sail = _spaceAgnosticIndentLevel
+            if sail > 0, _spaceAgnosticIndentLevel -= 1  # for missing indent
+            if sail < 0, _spaceAgnosticIndentLevel += 1  # for missing dedent
+            _finishSpaceAgnostic
+            if sail > 0
+                nothingMore = false  # TODO: feels wrong
+            else
+                nothingMore = .last.which == 'INDENT' and .peek.which <> 'INDENT'  # _spaceAgnosticIndentLevel == 0
         else
-            return method
+            nothingMore = not didIndent and .last.which == 'EOL'
+        return nothingMore
+        
+    #Helper for declareMethod; Error checks on initializer
+    def _verifyInitializer(returnType as ITypeProxy, implementsType as ITypeProxy?)
+        if .curBox inherits Interface
+            .throwError('Cannot declare an initializer for an interface.')
+        if returnType is not .typeProvider.voidType
+            .throwError('Cannot declare a return type for an initializer.')
+        if implementsType
+            .throwError('Cannot specify `implements` for an initializer.')
+            
 
     def declareMethodSig as MethodSig
         require _typeProvider
@@ -2049 +2054 @@
                     s.afterParserRecognizesStatement
                     if .optional('COMMA')
                         s = .multiTargetAssign(s to Expr)
-        if expectEOL
-            if .verbosity>=5
-                print '<> last statement start token=[token]'
-                print '<> s = [s]'
-            try
-                .expect('EOL')
-            catch pe as ParserException
-                # example: puts 5
-                token = .last(1)
-                if token <> nil
-                    sugg = if(token.text.length, Compiler.suggestionFor(token.text), nil)
-                    sugg = if(sugg, ' Try "[sugg]" instead of "[token.text]".', nil)
-                    if sugg, pe = pe.cloneWithMessage(pe.message + sugg)
-                throw pe
+        if expectEOL 
+            _handleStmtEOL(token, s)
+
         _finishSpaceAgnostic
         return s
+        
+    def _handleStmtEOL(token as IToken?, s as Stmt?)    
+        if .verbosity>=5
+            print '<> last statement start token=[token]'
+            print '<> s = [s]'
+        try
+            .expect('EOL')
+        catch pe as ParserException
+            # example: puts 5
+            token = .last(1)
+            if token <> nil
+                sugg = if(token.text.length, Compiler.suggestionFor(token.text), nil)
+                sugg = if(sugg, ' Try "[sugg]" instead of "[token.text]".', nil)
+                if sugg, pe = pe.cloneWithMessage(pe.message + sugg)
+            throw pe
 
 
     ##
@@ -2790 +2799 @@
         return left to !
 
     def expression2 as Expr
-        if _spaceAgnosticExprLevel > 0
-            _spaceAgnostic
+        if _spaceAgnosticExprLevel > 0, _spaceAgnostic
         peekToken = .peek
         peek = peekToken.which
         if _unaryOpPrec.containsKey(peek)
@@ -2804 +2812 @@
                 on 'OLD', return OldExpr(token, unaryExpr)
                 on 'REF', return RefExpr(token, unaryExpr)
                 else, return UnaryOpExpr(token, peek, unaryExpr)
-        # TODO: make a branch statement
-        else if peek=='LPAREN'
-            .grab
-            _spaceAgnosticExprLevel += 1
-            node = .expression(0, nil)
-            .expect('RPAREN')
-            _spaceAgnosticExprLevel -= 1
-            node.isParened = true
-            return node
-        else if peek=='DOT'
-            # leading dot
-            token = .grab
-            .opStack.push('DOT')
-            try
-                peekToken = .peek
-                peek = peekToken.which
-                if peek=='ID' or peekToken.isKeyword
-                    memberToken = .idOrKeyword
-                    expr = MemberExpr(memberToken) to Expr
-                else if peek=='OPEN_CALL'
-                    expr = .callExpr
-                else if peek=='OPEN_GENERIC'
-                    expr = .callExpr
+        branch peek
+            on 'LPAREN'
+                .grab
+                _spaceAgnosticExprLevel += 1
+                node = .expression(0, nil)
+                .expect('RPAREN')
+                _spaceAgnosticExprLevel -= 1
+                node.isParened = true
+                return node
+            on 'DOT'    # leading dot
+                token = .grab
+                .opStack.push('DOT')
+                try
+                    peekToken = .peek
+                    peek = peekToken.which
+                    if peek=='ID' or peekToken.isKeyword
+                        memberToken = .idOrKeyword
+                        expr = MemberExpr(memberToken) to Expr
+                    else if peek=='OPEN_CALL'
+                        expr = .callExpr
+                    else if peek=='OPEN_GENERIC'
+                        expr = .callExpr
+                    else
+                        .throwError('Syntax error after "."')
+                finally
+                    .opStack.pop
+                return BinaryOpExpr.make(token to !, 'DOT', ThisLit(token, isImplicit=true), expr)
+            on 'NIL',               return NilLiteral(.grab)
+            on 'TRUE' or 'FALSE',   return BoolLit(.grab)
+            on 'THIS',              return ThisLit(.grab)
+            on 'BASE',              return BaseLit(.grab)
+            on 'VAR'
+                assert _curCodePart
+                if _curCodePart inherits ProperDexerXetter
+                    return VarLit(.grab, _curCodePart)
                 else
-                    .throwError('Syntax error after "."')
-            finally
-                .opStack.pop
-            return BinaryOpExpr.make(token to !, 'DOT', ThisLit(token, isImplicit=true), expr)
-        else if peek=='NIL'
-            return NilLiteral(.grab)
-        else if peek=='TRUE'
-            return BoolLit(.grab)
-        else if peek=='FALSE'
-            return BoolLit(.grab)
-        else if peek=='THIS'
-            return ThisLit(.grab)
-        else if peek=='BASE'
-            return BaseLit(.grab)
-        else if peek=='VAR'
-            assert _curCodePart
-            if _curCodePart inherits ProperDexerXetter
-                return VarLit(.grab, _curCodePart)
-            else
-                .throwError('Cannot refer to `var` in expressions outside of a property `get` or `set`.')
-                throw FallThroughException() # stop a warning
-        else if peek=='CHAR_LIT_SINGLE'
-            return CharLit(.grab)
-        else if peek=='CHAR_LIT_DOUBLE'
-            return CharLit(.grab)
-        else if peek=='STRING_START_SINGLE'
-            return .stringWithSubstitutionLit('STRING_START_SINGLE', 'STRING_PART_SINGLE', 'STRING_STOP_SINGLE')
-        else if peek=='STRING_START_DOUBLE'
-            return .stringWithSubstitutionLit('STRING_START_DOUBLE', 'STRING_PART_DOUBLE', 'STRING_STOP_DOUBLE')
-        else if peek=='STRING_SINGLE'
-            return StringLit(.grab)
-        else if peek=='STRING_DOUBLE'
-            return StringLit(.grab)
-        else if peek=='INTEGER_LIT'
-            return IntegerLit(.grab)
-        else if peek=='DECIMAL_LIT'
-            return DecimalLit(.grab)
-        else if peek=='FRACTIONAL_LIT'
-            return FractionalLit(.grab)
-        else if peek=='FLOAT_LIT'
-            return FloatLit(.grab)
-        else if peek=='LBRACKET'
-            return .literalList
-        else if peek=='ARRAY_OPEN'
-            return .literalArray
-        else if peek=='LCURLY'
-            return .literalDictOrSet
-        else if peek.isOneOf('OPEN_DO.DO.')
-            return .doExpr
-        else if peek=='OPEN_IF'
-            return .ifExpr
-        else if peek=='FOR'
-            return .forExpr
-        else if peek=='OPEN_CALL'
-            return .callExpr
-        else if peek=='OPEN_GENERIC'
-            if .opStack.count and .opStack.peek == 'DOT'
-                return .callExpr
-            else
-                return TypeExpr(.typeId)
-        else if peek=='ID'
-            return .identifierExpr
-        else if peek.isOneOf('SHARP_OPEN.SHARP_SINGLE.SHARP_DOUBLE.')
-            return .sharpExpr
-        else if .opStack.count and .opStack.peek=='DOT' and .peek.isKeyword
-            return .identifierExpr
-        else
-            try
-                return .typeExpr
-            catch pe as ParserException
-                if .allowKeywordAssignment and peekToken.isKeyword and .peek is not nil and .peek.which == 'ASSIGN'
-                    assert .last is peekToken
-                    word, op = .last, .grab
-                    if word.text.startsWithNonLowerLetter
-                        .recordError(ErrorMessages.localVariablesMustStartLowercase)
-                    return AssignExpr(op, 'ASSIGN', IdentifierExpr(word), .expression)
-                else if pe.message.contains('Unrecognized type')
-                    msg = 'Expecting an expression.'
-                    if peekToken.isKeyword
-                        msg += ' "[peekToken.text]" is a reserved keyword that is not expected here.'
-                    .throwError(msg)
-                    throw FallThroughException()
+                    .throwError('Cannot refer to `var` in expressions outside of a property `get` or `set`.')
+                    throw FallThroughException() # stop a warning
+            on 'CHAR_LIT_SINGLE' or 'CHAR_LIT_DOUBLE' 
+                return CharLit(.grab)
+            on 'STRING_START_SINGLE'
+                return .stringWithSubstitutionLit('STRING_START_SINGLE', 'STRING_PART_SINGLE', 'STRING_STOP_SINGLE')
+            on 'STRING_START_DOUBLE'
+                return .stringWithSubstitutionLit('STRING_START_DOUBLE', 'STRING_PART_DOUBLE', 'STRING_STOP_DOUBLE')
+            on 'STRING_SINGLE' or 'STRING_DOUBLE'
+                return StringLit(.grab)
+            on 'INTEGER_LIT',       return IntegerLit(.grab)
+            on 'DECIMAL_LIT',       return DecimalLit(.grab)
+            on 'FRACTIONAL_LIT',    return FractionalLit(.grab)
+            on 'FLOAT_LIT',         return FloatLit(.grab)
+            on 'LBRACKET',          return .literalList
+            on 'ARRAY_OPEN',        return .literalArray
+            on 'LCURLY',            return .literalDictOrSet
+            on 'OPEN_DO' or 'DO',   return .doExpr
+            on 'OPEN_IF',           return .ifExpr
+            on 'FOR',               return .forExpr
+            on 'OPEN_CALL',         return .callExpr
+            on 'OPEN_GENERIC'
+                if .opStack.count and .opStack.peek == 'DOT'
+                    return .callExpr
                 else
-                    throw
+                    return TypeExpr(.typeId)
+            on 'ID', return .identifierExpr
+            on 'SHARP_OPEN' or 'SHARP_SINGLE' or 'SHARP_DOUBLE' 
+                return .sharpExpr
+            else 
+                if .opStack.count and .opStack.peek=='DOT' and .peek.isKeyword
+                    return .identifierExpr
+                try
+                    return .typeExpr
+                catch pe as ParserException
+                    if .allowKeywordAssignment and peekToken.isKeyword and .peek is not nil and .peek.which == 'ASSIGN'
+                        assert .last is peekToken
+                        word, op = .last, .grab
+                        if word.text.startsWithNonLowerLetter
+                            .recordError(ErrorMessages.localVariablesMustStartLowercase)
+                        return AssignExpr(op, 'ASSIGN', IdentifierExpr(word), .expression)
+                    else if pe.message.contains('Unrecognized type')
+                        msg = 'Expecting an expression.'
+                        if peekToken.isKeyword
+                            msg += ' "[peekToken.text]" is a reserved keyword that is not expected here.'
+                        .throwError(msg)
+                        throw FallThroughException()
+                    else
+                        throw
 
     def multiTargetAssign(arg0 as Expr) as Stmt
         # id, |[id,]... = <expr>