Ticket #275: main-wrapper-be.patch

Source/BackEndCommon/CurlyWriter.cobra

@@ -63 +63 @@
     def _isNewLine(value as String) as bool
         return value == _innerWriter.newLine or value == .newLine2
 
+    def bumpLineNum
+        _cobraLineNum += 1
+    
     # CC: shouldn't need the following
     def write(value as String?) is override
         base.write(value)

Source/Expr.cobra

@@ -584 +584 @@
     var _args as List<of Expr>
     var _hasParens as bool
     var _definition as IMember?
-    var _hasMainArgs as bool = false
 
     cue init(token as IToken, name as String, args as List<of Expr>, hasParens as bool)
         .init(token, name, nil, args, hasParens as bool)
@@ -614 +613 @@
 
     get hasParens from var
     
-    pro hasMainArgs from var
-        """Indicate if this call needs args passed into main method inserted by backend. For MainWrapper """
-        
     get willChangeVar as bool is override
         for arg in _args, if arg.willChangeVar, return true
         for arg in _args, if arg.direction <> Direction.In, return true

Source/Boxes.cobra

@@ -1226 +1226 @@
         base.init(token, idToken, name, paramList, isNames, attribs, implementsNodes, addsProxies, docString)
         _baseNode = baseNode
 
+    cue init(name as String, paramList as List<of IType>)
+        """ public skeleton class - init with given name and paramlist -  no baseclass, attributes, interfaces or mixins."""
+        .init(Token.empty, Token.empty, name, paramList, ['public'], AttributeList(), nil, List<of ITypeProxy>(), List<of ITypeProxy>(), '')
+            
     cue init(nativeType as NativeType, backend as BackEnd)
         # TODO: fix native
         base.init(TokenFix.empty, TokenFix.empty, backend.cobraNameForNativeBoxName(nativeType.name), List<of IType>(), List<of String>(), AttributeList(), List<of ITypeProxy>(), List<of ITypeProxy>(), nil)

Source/Module.cobra

@@ -70 +70 @@
         Holds name, docString and the topLevelNamespace as the root of the parsed AST nodes.
         Also handles binding by passing bind invocation onto its namespace to action.
     """
-
+    
+    pro isMainWrapper from var = false
+        """ synthesized wrapper for main"""
+        
     cue init(fileName as String, verbosity as int, docString as String, globalNS as NameSpace)
         base.init(fileName, verbosity, docString)
         _topNameSpace = NameSpace(globalNS, '(top namespace for module [fileName])')

Source/Phases/IdentifyMainPhase.cobra

@@ -57 +57 @@
         if not main.resultType.isDescendantOf(.compiler.voidType)
             main.recordError('The "main" method cannot have a return type. Use "CobraCore.exit(code)" instead.')
             didError = true
+        if  main.isProtected or main.isPrivate
+            access = if(main.isProtected, 'protected', 'private')
+            main.recordError('The "main" method cannot be "[access]" .')
         if not main.isShared
             init = main.parentBox.memberForName('cue.init')
             if init inherits MemberOverload
@@ -77 +80 @@
         name = 'MainWrapper'
         while c.symbolForName(name, false, false), name += 'X'
 
-        if false
-            # can't use cobra source because the other
-            # phases like parsing have already taken place
-            src = 'class [name]\n\t\def main is static\n\t\t[mainMethod.parentBox.qualifiedName]().[mainMethod.name]\n'
-            .options.addExtraSource(src)
-
-        implements_ = List<of ITypeProxy>()
-        adds_ = List<of ITypeProxy>()
-        theClass = Class(Token.empty, Token.empty, name, List<of IType>(), ['public'], AttributeList(), nil, implements_, adds_, '')
-
-        instantiate = PostCallExpr(Token.empty, TypeExpr(mainMethod.parentBox), List<of Expr>())
-        mainCall = CallExpr(Token.empty, 'main', List<of Expr>(), false)
-        mainCall.hasMainArgs = true # backend insert args passed to main
-        dot = DotExpr(Token.empty, 'DOT', instantiate, mainCall)
-
-        method = Method(Token.empty, Token.empty, theClass, 'main', List<of Param>(), .compiler.voidType, nil, ['shared'], mainMethod.attributes, '')
-        method.hasMainParams = true  # backend insert params on main method
-        method.addStmt(dot)
-
-        theClass.addDecl(method)
-
         mainModule = CobraModule(name+'.cobra', 0, '', .compiler.globalNS, isImplicit=true)
-        mainModule.topNameSpace.addDecl(theClass)
-
-        mainModule.bindUse
-        mainModule.bindInh
-        mainModule.bindInt
-        mainModule.bindImp
+        mainModule.isMainWrapper = true # mark us as special
         
+        # placeholder class provided only to store user method referenced
+        theClass = Class(name, List<of IType>())
+        theClass.addDecl(mainMethod) # store the  method to harvest contents later
+        mainModule.topNameSpace.addDecl(theClass) # data source for later harvest, not to generate a class+method
+
         c.modules.add(mainModule)
         c.mainMethodTypeName = name
 

Source/BackEndClr/SharpGenerator.cobra

@@ -465 +465 @@
             # TODO: list op sys
             sw.write('\n')
 
-            sw.write('using CobraLangInternal = Cobra.Lang[.compiler.embedRunTimeSuffix];\n')
-            
-            .topNameSpace.writeSharpDef(sw)
+            if .isMainWrapper 
+                .synthesizeSharpMainWrapper(sw)
+            else
+                sw.write('using CobraLangInternal = Cobra.Lang[.compiler.embedRunTimeSuffix];\n')
+                .topNameSpace.writeSharpDef(sw)
             d = sw.curlyToCobraLineNum
         if false
             bar = '----------------------------------------------'
@@ -479 +481 @@
     def writeSharpTestInvocation(sw as CurlyWriter) is override
         .topNameSpace.writeSharpTestInvocation(sw)
 
+        
+    def synthesizeSharpMainWrapper(sw as CurlyWriter)
+        """
+        Generate a wrapper class with a valid main method for C#/Clr
+            The wrapper will instantiate and call the provided user main method.
+        """
+            
+        # Module top namespace is expected to have a first entry which is a dummy class holding
+        #  the method (+ class ref) for the mainwrapper to instantiate and invoke.
+        assert .topNameSpace.declsInOrder.count
+        assert .topNameSpace.declsInOrder[0] inherits Class
+        placeHolderClass = .topNameSpace.declsInOrder[0] to Class
+        assert placeHolderClass.declsInOrder.count
+        assert placeHolderClass.declsInOrder[0] inherits AbstractMethod 
+        mainMethod = placeHolderClass.declsInOrder[0] to AbstractMethod  # method data
 
+        sw.write('// Cobra synthesized program entrypoint wrapping call to user supplied main method\n\n')
+        sw.writeAndIndent('class MainWrapper : System.Object {\n')
+        sw.bumpLineNum
+        for attr in mainMethod.attributes 
+            attr.writeSharpDef(sw, '', false)
+        if  mainMethod.attributes.count, sw.writeLine
+        sw.writeAndIndent('public static void Main() {\n')  
+        sw.bumpLineNum
+        sw.writeLine('(new [mainMethod.parentBox.qualifiedName]()).Main();')
+        sw.bumpLineNum
+        sw.dedentAndWrite('} // end Main\n\n')
+        sw.bumpLineNum
+        sw.writeLine('public  MainWrapper()')
+        sw.indentAndWrite(': base() {\n')
+        sw.dedentAndWrite('}')
+        sw.write('\n')
+        sw.writeLine('} // class MainWrapper')
+        
 ##
 ## Container and friends
 ##
@@ -1761 +1796 @@
         sw.write('CobraLangInternal.CobraImp.PopFrame();\n')
         sw.dedentAndWrite('}\n')
 
-
+            
 class Initializer is partial
 
     def innerWriteSharpDef(sw as CurlyWriter)

Source/BackEndJvm/JavaGenerator.cobra

@@ -336 +336 @@
             # TODO: list op sys
             sw.write('\n')
 
-            .topNameSpace.writeJavaDef(sw)
+            if .isMainWrapper   
+                .synthesizeJavaMainWrapper(sw)
+            else
+                .topNameSpace.writeJavaDef(sw)
             d = sw.curlyToCobraLineNum
         return d
 
     def writeJavaTestInvocation(sw as CurlyWriter) is override
         # TODO: .topNameSpace.writeJavaTestInvocation(sw)
         pass
+        
+    def synthesizeJavaMainWrapper(sw as CurlyWriter)
+        """
+        Generate a wrapper class with a valid main method for java.
+            The wrapper will instantiate and call the provided user main method.
+        """
+        # Module top namespace is expected to have a single entry which is a dummy class holding
+        #  the method (+ class) for the mainwrapper to instantiate and invoke.
+        assert .topNameSpace.declsInOrder.count
+        assert .topNameSpace.declsInOrder[0] inherits Class
+        placeHolderClass = .topNameSpace.declsInOrder[0] to Class
+        assert placeHolderClass.declsInOrder.count
+        assert placeHolderClass.declsInOrder[0] inherits AbstractMethod 
+        mainMethod = placeHolderClass.declsInOrder[0] to AbstractMethod  # method data
 
+        sw.write('// Cobra synthesized program entrypoint wrapping call to user supplied main method\n\n')
+        sw.writeAndIndent('class MainWrapper extends java.lang.Object {\n')
+        sw.bumpLineNum
+        for attr in mainMethod.attributes 
+            attr.writeSharpDef(sw, '', false)
+        if  mainMethod.attributes.count, sw.writeLine
+        sw.writeAndIndent(r'static public void main(String[] args) {')
+        sw.writeLine
+        sw.bumpLineNum
+        sw.writeLine('//cobra.lang.CobraCore.setCommandLineArgs(args); ')
+        sw.writeLine('(new [mainMethod.parentBox.javaRef]()).main(args);')
+        sw.bumpLineNum
+        sw.dedentAndWrite('} // end MainWrapper.main\n\n')
+        sw.bumpLineNum
+        sw.writeLine('public  MainWrapper() {')
+        sw.indentAndWrite('//super(); \n')
+        sw.dedentAndWrite('}')
+        sw.writeLine
+        sw.dedentAndWrite('} // class MainWrapper')
+        sw.writeLine
+        
 
 ##
 ## Container and friends
@@ -1598 +1636 @@
         .writeJavaIsNames(sw)
         sw.write('[returnType.javaRef] [name][.javaGenericParams]')
         if .hasMainParams   # insert args for main method for this backend
-            sw.write(r'(String[] args)')
+            sw.write(r'(String[] args)') # match to CobraModule.synthesizeJavaMainWrapper
         else
             .writeJavaParams(sw)
         if .genericParams.count
@@ -2464 +2502 @@
             sw.write(sep)
             arg.writeJavaDefInContext(sw)
             sep = ', '
-        if .hasMainArgs         # for MainWrapper - pass through args fm main method
-            sw.write('args')    # same name(s) as inserted args on main method 
         sw.write(')')
 
     def writeJavaBreakdownItems(sw as CurlyWriter) is override

Tests/110-basics-two/170-main/260-main-is-private.cobra

@@ +1 @@
+class A
+
+    def main is private #  .error. the "main" method cannot be "private" 
+        print 'hello'

Tests/110-basics-two/170-main/265-main-is-protected.cobra

@@ +1 @@
+class A
+
+    def main is protected #  .error. the "main" method cannot be "protected" 
+        print 'hello'