Author: gert
Date: 2005-06-26 16:53:56 -0400 (Sun, 26 Jun 2005)
New Revision: 46524

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: Make tests pass on MS.NET 1.x and 2.0, and
Mono 1.0/2.0.
* VBCodeGenerator.cs: Minor fixes for compatibility with MS.NET 2.0.


Modified: trunk/mcs/class/System/Microsoft.VisualBasic/ChangeLog
===================================================================
--- trunk/mcs/class/System/Microsoft.VisualBasic/ChangeLog      2005-06-26 
20:15:40 UTC (rev 46523)
+++ trunk/mcs/class/System/Microsoft.VisualBasic/ChangeLog      2005-06-26 
20:53:56 UTC (rev 46524)
@@ -1,5 +1,9 @@
 2005-06-26  Gert Driesen <[EMAIL PROTECTED]>
 
+       * VBCodeGenerator.cs: Minor fixes for compatibility with MS.NET 2.0.
+
+2005-06-26  Gert Driesen <[EMAIL PROTECTED]>
+
        * VBCodeGenerator.cs: Fixed generated code for attributes on ctors.
        Implemented Base/Chained ctor args.
 

Modified: trunk/mcs/class/System/Microsoft.VisualBasic/VBCodeGenerator.cs
===================================================================
--- trunk/mcs/class/System/Microsoft.VisualBasic/VBCodeGenerator.cs     
2005-06-26 20:15:40 UTC (rev 46523)
+++ trunk/mcs/class/System/Microsoft.VisualBasic/VBCodeGenerator.cs     
2005-06-26 20:53:56 UTC (rev 46524)
@@ -686,29 +686,29 @@
                                output.Write ("WriteOnly " );
 
                        output.Write ("Property " );
-                       
-                       OutputTypeNamePair (property.Type, property.Name);
+
+                       Output.Write (property.Name);
+#if NET_2_0
+                       Output.Write ('(');
+                       Output.Write (')');
+#endif
+                       Output.Write (" As ");
+                       Output.Write (GetTypeOutput(property.Type));
                        output.WriteLine ();
                        ++Indent;
 
                        if (property.HasGet) {
                                output.WriteLine ("Get");
                                ++Indent;
-
                                GenerateStatements (property.GetStatements);
-
                                --Indent;
                                output.WriteLine ("End Get");
                        }
                        
                        if (property.HasSet) {
-                               output.Write ("Set (");
-                               OutputTypeNamePair (property.Type, "Value");
-                               output.WriteLine (")");
+                               output.WriteLine ("Set");
                                ++Indent;
-
                                GenerateStatements (property.SetStatements);
-
                                --Indent;
                                output.WriteLine ("End Set");
                        }
@@ -1022,16 +1022,23 @@
                                //
                                // FUNNY! if the scope value is
                                // rubbish (0 or >Const), and access
-                               // is public or protected, make it
+                               // is public, protected make it
                                // "virtual".
                                //
                                // i'm not sure whether this is 100%
                                // correct, but it seems to be MS
-                               // behavior. 
+                               // behavior.
                                //
+                               // On MS.NET 2.0, internal properties
+                               // are also marked "virtual".
+                               //
                                MemberAttributes access = attributes & 
MemberAttributes.AccessMask;
-                               if ( access == MemberAttributes.Public || 
-                                       access == MemberAttributes.Family )
+                               if (access == MemberAttributes.Public || 
+#if NET_2_0
+                                       access == MemberAttributes.Family || 
access == MemberAttributes.Assembly)
+#else
+                                       access == MemberAttributes.Family)
+#endif
                                        Output.Write ("Overridable ");
                                break;
                        }

Modified: trunk/mcs/class/System/Test/Microsoft.VisualBasic/ChangeLog
===================================================================
--- trunk/mcs/class/System/Test/Microsoft.VisualBasic/ChangeLog 2005-06-26 
20:15:40 UTC (rev 46523)
+++ trunk/mcs/class/System/Test/Microsoft.VisualBasic/ChangeLog 2005-06-26 
20:53:56 UTC (rev 46524)
@@ -1,5 +1,10 @@
 2005-06-26  Gert Driesen <[EMAIL PROTECTED]>
 
+       * CodeGeneratorFromTypeTest.cs: Make tests pass on MS.NET 1.x and 2.0,
+       and Mono (1.0/2.0).
+
+2005-06-26  Gert Driesen <[EMAIL PROTECTED]>
+
        * CodeGeneratorFromTypeTest.cs: Added tests for ctor level attributes
        and Base/Chained ctor args.
 

Modified: 
trunk/mcs/class/System/Test/Microsoft.VisualBasic/CodeGeneratorFromTypeTest.cs
===================================================================
--- 
trunk/mcs/class/System/Test/Microsoft.VisualBasic/CodeGeneratorFromTypeTest.cs  
    2005-06-26 20:15:40 UTC (rev 46523)
+++ 
trunk/mcs/class/System/Test/Microsoft.VisualBasic/CodeGeneratorFromTypeTest.cs  
    2005-06-26 20:53:56 UTC (rev 46524)
@@ -185,8 +185,16 @@
 
                        Generate ();
                        Assert.AreEqual (string.Format 
(CultureInfo.InvariantCulture,
-                               "Public Class Test1{0}    {0}    <A(),  _{0}    
 B()>  _{0}    "
-                               + "Private Property  As System.Void{0}    End 
Property{0}"
+                               "Public Class Test1{0}"
+                               + "    {0}"
+                               + "    <A(),  _{0}"
+                               + "     B()>  _{0}"
+#if NET_2_0
+                               + "    Private Property () As System.Void{0}"
+#else
+                               + "    Private Property  As System.Void{0}"
+#endif
+                               + "    End Property{0}"
                                + "End Class{0}", writer.NewLine), Code);
                }
 
@@ -205,12 +213,160 @@
                        Assert.AreEqual (string.Format 
(CultureInfo.InvariantCulture,
                                "Public Class Test1{0}"
                                + "    {0}"
+#if NET_2_0
+                               + "    Public Overridable Property Name() As 
Integer{0}"
+#else
                                + "    Public Overridable Property Name As 
Integer{0}"
+#endif
                                + "    End Property{0}"
                                + "End Class{0}", writer.NewLine), Code);
                }
 
                [Test]
+               public void PropertyMembersTypeGetOnly ()
+               {
+                       type.Name = "Test1";
+
+                       CodeMemberProperty property = new CodeMemberProperty ();
+                       property.Name = "Name";
+                       property.Attributes = MemberAttributes.Family;
+                       property.HasGet = true;
+                       property.Type = new CodeTypeReference (typeof (int));
+                       type.Members.Add (property);
+
+                       Generate ();
+                       Assert.AreEqual (string.Format 
(CultureInfo.InvariantCulture,
+                               "Public Class Test1{0}"
+                               + "    {0}"
+#if NET_2_0
+                               + "    Protected Overridable ReadOnly Property 
Name() As Integer{0}"
+#else
+                               + "    Protected Overridable ReadOnly Property 
Name As Integer{0}"
+#endif
+                               + "        Get{0}"
+                               + "        End Get{0}"
+                               + "    End Property{0}"
+                               + "End Class{0}", writer.NewLine), Code);
+               }
+
+               [Test]
+               public void PropertyMembersTypeSetOnly ()
+               {
+                       type.Name = "Test1";
+
+                       CodeMemberProperty property = new CodeMemberProperty ();
+                       property.Name = "Name";
+                       property.Attributes = 
MemberAttributes.FamilyAndAssembly;
+                       property.HasSet = true;
+                       property.Type = new CodeTypeReference (typeof (int));
+                       type.Members.Add (property);
+
+                       Generate ();
+                       Assert.AreEqual (string.Format 
(CultureInfo.InvariantCulture,
+                               "Public Class Test1{0}"
+                               + "    {0}"
+#if NET_2_0
+                               + "    Friend WriteOnly Property Name() As 
Integer{0}"
+#else
+                               + "    Friend WriteOnly Property Name As 
Integer{0}"
+#endif
+                               + "        Set{0}"
+                               + "        End Set{0}"
+                               + "    End Property{0}"
+                               + "End Class{0}", writer.NewLine), Code);
+               }
+
+               [Test]
+               public void PropertyMembersTypeGetSet ()
+               {
+                       type.Name = "Test1";
+
+                       CodeMemberProperty property = new CodeMemberProperty ();
+                       property.Name = "Name";
+                       property.Attributes = MemberAttributes.Family;
+                       property.HasGet = true;
+                       property.HasSet = true;
+                       property.Type = new CodeTypeReference (typeof (int));
+                       type.Members.Add (property);
+
+                       Generate ();
+                       Assert.AreEqual (string.Format 
(CultureInfo.InvariantCulture,
+                               "Public Class Test1{0}"
+                               + "    {0}"
+#if NET_2_0
+                               + "    Protected Overridable Property Name() As 
Integer{0}"
+#else
+                               + "    Protected Overridable Property Name As 
Integer{0}"
+#endif
+                               + "        Get{0}"
+                               + "        End Get{0}"
+                               + "        Set{0}"
+                               + "        End Set{0}"
+                               + "    End Property{0}"
+                               + "End Class{0}", writer.NewLine), Code);
+               }
+
+#if !NET_2_0
+               // A bug in MS.NET 1.x causes MemberAttributes.FamilyOrAssembly 
to be 
+               // generated as Protected
+               [Category("NotDotNet")]
+#endif
+               [Test]
+               public void PropertyMembersTypeFamilyOrAssembly ()
+               {
+                       type.Name = "Test1";
+
+                       CodeMemberProperty property = new CodeMemberProperty ();
+                       property.Name = "Name";
+                       property.Attributes = MemberAttributes.FamilyOrAssembly;
+                       property.Type = new CodeTypeReference (typeof (int));
+
+                       type.Members.Add (property);
+
+                       Generate ();
+                       Assert.AreEqual (string.Format 
(CultureInfo.InvariantCulture,
+                               "Public Class Test1{0}"
+                               + "    {0}"
+#if NET_2_0
+                               + "    Protected Friend Property Name() As 
Integer{0}"
+#else
+                               + "    Protected Friend Property Name As 
Integer{0}"
+#endif
+                               + "    End Property{0}"
+                               + "End Class{0}", writer.NewLine), Code);
+               }
+
+#if !NET_2_0
+               // A bug in MS.NET 1.x causes MemberAttributes.Assembly to be 
generated
+               // as Protected
+               [Category ("NotDotNet")]
+#endif
+               [Test]
+               public void PropertyMembersTypeAssembly ()
+               {
+                       type.Name = "Test1";
+
+                       CodeMemberProperty property = new CodeMemberProperty ();
+                       property.Name = "Name";
+                       property.Attributes = MemberAttributes.Assembly;
+                       property.Type = new CodeTypeReference (typeof (int));
+
+                       type.Members.Add (property);
+
+                       Generate ();
+                       Assert.AreEqual (string.Format 
(CultureInfo.InvariantCulture,
+                               "Public Class Test1{0}"
+                               + "    {0}"
+#if NET_2_0
+                               + "    Friend Overridable Property Name() As 
Integer{0}"
+#else
+                               + "    Friend Property Name As Integer{0}"
+#endif
+                               + "    End Property{0}"
+                               + "End Class{0}", writer.NewLine), Code);
+               }
+
+               [Test]
                public void MethodMembersTypeTest1 ()
                {
                        type.Name = "Test1";

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

Reply via email to