Author: gert
Date: 2005-06-26 07:41:24 -0400 (Sun, 26 Jun 2005)
New Revision: 46517

Modified:
   trunk/mcs/class/System/Microsoft.VisualBasic/ChangeLog
   trunk/mcs/class/System/Microsoft.VisualBasic/VBCodeGenerator.cs
   trunk/mcs/class/System/Test/Microsoft.VisualBasic/ChangeLog
   
trunk/mcs/class/System/Test/Microsoft.VisualBasic/CodeGeneratorFromTypeTest.cs
Log:
* CodeGeneratorFromTypeTest.cs: Added tests for ctor level attributes and 
Base/Chained ctor args.
* VBCodeGenerator.cs: Fixed generated code for attributes on ctors.
Implemented Base/Chained ctor args.


Modified: trunk/mcs/class/System/Microsoft.VisualBasic/ChangeLog
===================================================================
--- trunk/mcs/class/System/Microsoft.VisualBasic/ChangeLog      2005-06-26 
08:56:28 UTC (rev 46516)
+++ trunk/mcs/class/System/Microsoft.VisualBasic/ChangeLog      2005-06-26 
11:41:24 UTC (rev 46517)
@@ -1,5 +1,10 @@
 2005-06-26  Gert Driesen <[EMAIL PROTECTED]>
 
+       * VBCodeGenerator.cs: Fixed generated code for attributes on ctors.
+       Implemented Base/Chained ctor args.
+
+2005-06-26  Gert Driesen <[EMAIL PROTECTED]>
+
        * VBCodeGenerator.cs: Fixed generated code for method, property
        and parameter level attributes. Fixed code generated for
        FieldDirection.

Modified: trunk/mcs/class/System/Microsoft.VisualBasic/VBCodeGenerator.cs
===================================================================
--- trunk/mcs/class/System/Microsoft.VisualBasic/VBCodeGenerator.cs     
2005-06-26 08:56:28 UTC (rev 46516)
+++ trunk/mcs/class/System/Microsoft.VisualBasic/VBCodeGenerator.cs     
2005-06-26 11:41:24 UTC (rev 46517)
@@ -313,9 +313,7 @@
 
                protected override void GenerateParameterDeclarationExpression 
(CodeParameterDeclarationExpression e)
                {
-                       if (e.CustomAttributes.Count > 0)
-                               OutputAttributes (e.CustomAttributes, null,
-                                       LineHandling.InLine);
+                       OutputAttributes (e.CustomAttributes, null, 
LineHandling.InLine);
                        OutputDirection (e.Direction);
                        OutputTypeNamePair (e.Type, e.Name);
                }
@@ -569,12 +567,10 @@
                {
                        TextWriter output = Output;
 
-                       if (eventRef.CustomAttributes.Count > 0)
-                               OutputAttributes (eventRef.CustomAttributes, 
null, 
-                                       LineHandling.ContinueLine);
+                       OutputAttributes (eventRef.CustomAttributes, null, 
+                               LineHandling.ContinueLine);
 
                        MemberAttributes attributes = eventRef.Attributes;
-
                        OutputMemberAccessModifier (attributes);
                        OutputMemberScopeModifier (attributes | 
MemberAttributes.Final);  // Don't output "Overridable"
 
@@ -587,9 +583,8 @@
                {
                        TextWriter output = Output;
 
-                       if (field.CustomAttributes.Count > 0)
-                               OutputAttributes (field.CustomAttributes, null, 
-                                       LineHandling.ContinueLine);
+                       OutputAttributes (field.CustomAttributes, null, 
+                               LineHandling.ContinueLine);
 
                        MemberAttributes attributes = field.Attributes;
                        OutputMemberAccessModifier (attributes);
@@ -624,12 +619,10 @@
 
                        TextWriter output = Output;
 
-                       if (method.CustomAttributes.Count > 0)
-                               OutputAttributes (method.CustomAttributes, 
null, 
-                                       LineHandling.ContinueLine);
+                       OutputAttributes (method.CustomAttributes, null, 
+                               LineHandling.ContinueLine);
 
                        MemberAttributes attributes = method.Attributes;
-
                        OutputMemberAccessModifier (attributes);
                        OutputMemberScopeModifier (attributes);
 
@@ -679,9 +672,8 @@
                {
                        TextWriter output = Output;
 
-                       if (property.CustomAttributes.Count > 0)
-                               OutputAttributes (property.CustomAttributes, 
null, 
-                                       LineHandling.ContinueLine);
+                       OutputAttributes (property.CustomAttributes, null, 
+                               LineHandling.ContinueLine);
 
                        MemberAttributes attributes = property.Attributes;
                        OutputMemberAccessModifier (attributes);
@@ -725,17 +717,33 @@
                        output.WriteLine ("End Property");
                }
 
-               [MonoTODO ("not implemented")]
                protected override void GenerateConstructor (CodeConstructor 
constructor, CodeTypeDeclaration declaration)
                {
-                       if (constructor.CustomAttributes.Count > 0)
-                               OutputAttributeDeclarations 
(constructor.CustomAttributes);
+                       OutputAttributes (constructor.CustomAttributes, null,
+                               LineHandling.ContinueLine);
                        OutputMemberAccessModifier (constructor.Attributes);
                        Output.Write ("Sub New(");
                        OutputParameters (constructor.Parameters);
                        Output.WriteLine (")");
-                       // Handle BaseConstructorArgs, ChainedConstructorArgs, 
ImplementationTypes
                        Indent++;
+                       // check if ctor passes args on to other ctor in class
+                       CodeExpressionCollection ctorArgs = 
constructor.ChainedConstructorArgs;
+                       if (ctorArgs.Count > 0) {
+                               Output.Write ("Me.New(");
+                               OutputExpressionList (ctorArgs);
+                               Output.WriteLine (")");
+                       } else {
+                               // check if ctor passes args on to ctor in base 
class
+                               ctorArgs = constructor.BaseConstructorArgs;
+                               if (ctorArgs.Count > 0) {
+                                       Output.Write ("MyBase.New(");
+                                       OutputExpressionList (ctorArgs);
+                                       Output.WriteLine (")");
+                               } else {
+                                       // call default base ctor
+                                       Output.WriteLine ("MyBase.New");
+                               }
+                       }
                        GenerateStatements (constructor.Statements);
                        Indent--;
                        Output.WriteLine ("End Sub");
@@ -757,6 +765,7 @@
 
                        OutputAttributes (declaration.CustomAttributes, null, 
                                LineHandling.ContinueLine);
+
                        TypeAttributes attributes = declaration.TypeAttributes;
                        OutputTypeAttributes (attributes,
                                declaration.IsStruct,

Modified: trunk/mcs/class/System/Test/Microsoft.VisualBasic/ChangeLog
===================================================================
--- trunk/mcs/class/System/Test/Microsoft.VisualBasic/ChangeLog 2005-06-26 
08:56:28 UTC (rev 46516)
+++ trunk/mcs/class/System/Test/Microsoft.VisualBasic/ChangeLog 2005-06-26 
11:41:24 UTC (rev 46517)
@@ -1,5 +1,10 @@
 2005-06-26  Gert Driesen <[EMAIL PROTECTED]>
 
+       * CodeGeneratorFromTypeTest.cs: Added tests for ctor level attributes
+       and Base/Chained ctor args.
+
+2005-06-26  Gert Driesen <[EMAIL PROTECTED]>
+
        * CodeGeneratorFromCompileUnitTest.cs: Removed last usage of
        Assertion class.
        * CodeGeneratorFromTypeTest.cs: Added tests for method, property and

Modified: 
trunk/mcs/class/System/Test/Microsoft.VisualBasic/CodeGeneratorFromTypeTest.cs
===================================================================
--- 
trunk/mcs/class/System/Test/Microsoft.VisualBasic/CodeGeneratorFromTypeTest.cs  
    2005-06-26 08:56:28 UTC (rev 46516)
+++ 
trunk/mcs/class/System/Test/Microsoft.VisualBasic/CodeGeneratorFromTypeTest.cs  
    2005-06-26 11:41:24 UTC (rev 46517)
@@ -289,6 +289,7 @@
                        // first parameter
                        CodeParameterDeclarationExpression param = new 
CodeParameterDeclarationExpression (
                                typeof (object), "value");
+                       method.Parameters.Add (param);
 
                        CodeAttributeDeclaration attrDec = new 
CodeAttributeDeclaration ();
                        attrDec.Name = "A";
@@ -298,7 +299,6 @@
                        attrDec.Name = "B";
                        param.CustomAttributes.Add (attrDec);
 
-                       method.Parameters.Add (param);
 
                        // second parameter
                        param = new CodeParameterDeclarationExpression (typeof 
(int), "index");
@@ -327,5 +327,269 @@
                                + "    End Function{0}"
                                + "End Class{0}", writer.NewLine), Code);
                }
+
+               [Test]
+               public void ConstructorAttributesTest ()
+               {
+                       type.Name = "Test1";
+
+                       CodeConstructor ctor = new CodeConstructor ();
+
+                       CodeAttributeDeclaration attrDec = new 
CodeAttributeDeclaration ();
+                       attrDec.Name = "A";
+                       ctor.CustomAttributes.Add (attrDec);
+
+                       attrDec = new CodeAttributeDeclaration ();
+                       attrDec.Name = "B";
+                       ctor.CustomAttributes.Add (attrDec);
+
+                       type.Members.Add (ctor);
+
+                       Generate ();
+                       Assert.AreEqual (string.Format 
(CultureInfo.InvariantCulture,
+                               "Public Class Test1{0}"
+                               + "    {0}"
+                               + "    <A(),  _{0}"
+                               + "     B()>  _{0}"
+                               + "    Private Sub New(){0}"
+                               + "        MyBase.New{0}"
+                               + "    End Sub{0}"
+                               + "End Class{0}", writer.NewLine), Code);
+               }
+
+               [Test]
+               public void ConstructorParametersTest ()
+               {
+                       type.Name = "Test1";
+
+                       CodeConstructor ctor = new CodeConstructor ();
+                       ctor.Name = "Whatever";
+                       ctor.Attributes = MemberAttributes.Public;
+
+                       CodeParameterDeclarationExpression param = new 
CodeParameterDeclarationExpression (
+                               typeof (object), "value1");
+                       ctor.Parameters.Add (param);
+
+                       param = new CodeParameterDeclarationExpression (
+                               typeof (object), "value2");
+                       param.Direction = FieldDirection.In;
+                       ctor.Parameters.Add (param);
+
+                       param = new CodeParameterDeclarationExpression (typeof 
(int), "index");
+                       param.Direction = FieldDirection.Out;
+                       ctor.Parameters.Add (param);
+
+                       param = new CodeParameterDeclarationExpression (typeof 
(int), "count");
+                       param.Direction = FieldDirection.Ref;
+                       ctor.Parameters.Add (param);
+
+                       type.Members.Add (ctor);
+
+                       Generate ();
+                       Assert.AreEqual (string.Format 
(CultureInfo.InvariantCulture,
+                               "Public Class Test1{0}"
+                               + "    {0}"
+                               + "    Public Sub New(ByVal value1 As Object, 
ByVal value2 As Object, ByRef index As Integer, ByRef count As Integer){0}"
+                               + "        MyBase.New{0}"
+                               + "    End Sub{0}"
+                               + "End Class{0}", writer.NewLine), Code);
+               }
+
+               [Test]
+               public void ConstructorParameterAttributesTest ()
+               {
+                       type.Name = "Test1";
+
+                       CodeConstructor ctor = new CodeConstructor ();
+                       ctor.Name = "Something";
+                       ctor.Attributes = MemberAttributes.Public;
+
+                       // first parameter
+                       CodeParameterDeclarationExpression param = new 
CodeParameterDeclarationExpression (
+                               typeof (object), "value");
+                       ctor.Parameters.Add (param);
+
+                       CodeAttributeDeclaration attrDec = new 
CodeAttributeDeclaration ();
+                       attrDec.Name = "A";
+                       param.CustomAttributes.Add (attrDec);
+
+                       attrDec = new CodeAttributeDeclaration ();
+                       attrDec.Name = "B";
+                       param.CustomAttributes.Add (attrDec);
+
+                       // second parameter
+                       param = new CodeParameterDeclarationExpression (typeof 
(int), "index");
+                       param.Direction = FieldDirection.Out;
+                       ctor.Parameters.Add (param);
+
+                       attrDec = new CodeAttributeDeclaration ();
+                       attrDec.Name = "C";
+                       attrDec.Arguments.Add (new CodeAttributeArgument ("A1",
+                               new CodePrimitiveExpression (false)));
+                       attrDec.Arguments.Add (new CodeAttributeArgument ("A2",
+                               new CodePrimitiveExpression (true)));
+                       param.CustomAttributes.Add (attrDec);
+
+                       attrDec = new CodeAttributeDeclaration ();
+                       attrDec.Name = "D";
+                       param.CustomAttributes.Add (attrDec);
+
+                       type.Members.Add (ctor);
+
+                       Generate ();
+                       Assert.AreEqual (string.Format 
(CultureInfo.InvariantCulture,
+                               "Public Class Test1{0}"
+                               + "    {0}"
+                               + "    Public Sub New(<A(), B()> ByVal value As 
Object, <C(A1:=false, A2:=true), D()> ByRef index As Integer){0}"
+                               + "        MyBase.New{0}"
+                               + "    End Sub{0}"
+                               + "End Class{0}", writer.NewLine), Code);
+               }
+
+               [Test]
+               public void BaseConstructorSingleArg ()
+               {
+                       type.Name = "Test1";
+
+                       CodeConstructor ctor = new CodeConstructor ();
+                       ctor.Name = "Something";
+                       ctor.Attributes = MemberAttributes.Public;
+
+                       // first parameter
+                       CodeParameterDeclarationExpression param = new 
CodeParameterDeclarationExpression (
+                               typeof (object), "value1");
+                       ctor.Parameters.Add (param);
+
+                       // second parameter
+                       param = new CodeParameterDeclarationExpression (typeof 
(int), "value2");
+                       param.Direction = FieldDirection.Out;
+                       ctor.Parameters.Add (param);
+
+                       // base ctor args
+                       ctor.BaseConstructorArgs.Add (new 
CodeVariableReferenceExpression ("value1"));
+
+                       type.Members.Add (ctor);
+
+                       Generate ();
+                       Assert.AreEqual (string.Format 
(CultureInfo.InvariantCulture,
+                               "Public Class Test1{0}"
+                               + "    {0}"
+                               + "    Public Sub New(ByVal value1 As Object, 
ByRef value2 As Integer){0}"
+                               + "        MyBase.New(value1){0}"
+                               + "    End Sub{0}"
+                               + "End Class{0}", writer.NewLine), Code);
+               }
+
+               [Test]
+               public void BaseConstructorMultipleArgs ()
+               {
+                       type.Name = "Test1";
+
+                       CodeConstructor ctor = new CodeConstructor ();
+                       ctor.Name = "Something";
+                       ctor.Attributes = MemberAttributes.Public;
+
+                       // first parameter
+                       CodeParameterDeclarationExpression param = new 
CodeParameterDeclarationExpression (
+                               typeof (object), "value1");
+                       ctor.Parameters.Add (param);
+
+                       // second parameter
+                       param = new CodeParameterDeclarationExpression (typeof 
(int), "value2");
+                       param.Direction = FieldDirection.Out;
+                       ctor.Parameters.Add (param);
+
+                       // base ctor args
+                       ctor.BaseConstructorArgs.Add (new 
CodeVariableReferenceExpression ("value1"));
+                       ctor.BaseConstructorArgs.Add (new 
CodeVariableReferenceExpression ("value2"));
+
+                       type.Members.Add (ctor);
+
+                       Generate ();
+                       Assert.AreEqual (string.Format 
(CultureInfo.InvariantCulture,
+                               "Public Class Test1{0}"
+                               + "    {0}"
+                               + "    Public Sub New(ByVal value1 As Object, 
ByRef value2 As Integer){0}"
+                               + "        MyBase.New(value1, value2){0}"
+                               + "    End Sub{0}"
+                               + "End Class{0}", writer.NewLine), Code);
+               }
+
+               [Test]
+               public void ChainedConstructorSingleArg ()
+               {
+                       type.Name = "Test1";
+
+                       CodeConstructor ctor = new CodeConstructor ();
+                       ctor.Name = "Something";
+                       ctor.Attributes = MemberAttributes.Public;
+
+                       // first parameter
+                       CodeParameterDeclarationExpression param = new 
CodeParameterDeclarationExpression (
+                               typeof (object), "value1");
+                       ctor.Parameters.Add (param);
+
+                       // second parameter
+                       param = new CodeParameterDeclarationExpression (typeof 
(int), "value2");
+                       param.Direction = FieldDirection.Out;
+                       ctor.Parameters.Add (param);
+
+                       // chained ctor args
+                       ctor.ChainedConstructorArgs.Add (new 
CodeVariableReferenceExpression ("value1"));
+
+                       // should be ignored as chained ctor args should take 
precedence over base 
+                       // ctor args
+                       ctor.BaseConstructorArgs.Add (new 
CodeVariableReferenceExpression ("value3"));
+
+                       type.Members.Add (ctor);
+
+                       Generate ();
+                       Assert.AreEqual (string.Format 
(CultureInfo.InvariantCulture,
+                               "Public Class Test1{0}"
+                               + "    {0}"
+                               + "    Public Sub New(ByVal value1 As Object, 
ByRef value2 As Integer){0}"
+                               + "        Me.New(value1){0}"
+                               + "    End Sub{0}"
+                               + "End Class{0}", writer.NewLine), Code);
+               }
+
+               [Test]
+               public void ChainedConstructorMultipleArgs ()
+               {
+                       type.Name = "Test1";
+
+                       CodeConstructor ctor = new CodeConstructor ();
+                       ctor.Name = "Something";
+                       ctor.Attributes = MemberAttributes.Public;
+
+                       // first parameter
+                       CodeParameterDeclarationExpression param = new 
CodeParameterDeclarationExpression (
+                               typeof (object), "value1");
+                       ctor.Parameters.Add (param);
+
+                       // second parameter
+                       param = new CodeParameterDeclarationExpression (typeof 
(int), "value2");
+                       param.Direction = FieldDirection.Out;
+                       ctor.Parameters.Add (param);
+
+                       // chained ctor args
+                       ctor.ChainedConstructorArgs.Add (new 
CodeVariableReferenceExpression ("value1"));
+                       ctor.ChainedConstructorArgs.Add (new 
CodeVariableReferenceExpression ("value2"));
+
+                       // should be ignored as chained ctor args should take 
precedence over base 
+                       // ctor args
+                       ctor.BaseConstructorArgs.Add (new 
CodeVariableReferenceExpression ("value3"));
+
+                       type.Members.Add (ctor);
+
+                       Generate ();
+                       Assert.AreEqual (string.Format 
(CultureInfo.InvariantCulture,
+                               "Public Class Test1{0}"
+                               + "    {0}"
+                               + "    Public Sub New(ByVal value1 As Object, 
ByRef value2 As Integer){0}"
+                               + "        Me.New(value1, value2){0}"
+                               + "    End Sub{0}"
+                               + "End Class{0}", writer.NewLine), Code);
+               }
        }
 }

_______________________________________________
Mono-patches maillist  -  [email protected]
http://lists.ximian.com/mailman/listinfo/mono-patches

Reply via email to