Fix all over-long lines

This does *not* change grammar.md, as that will be updated automatically.

The large XML document is changed from 4-space indent to 2-space to simplify things.

Author: jskeet

standard/arrays.md

@@ -82,10 +82,10 @@ Similarly, a single-dimensional array `T[]` also implements the interface `Syste
 >         IList<string> lst5 = (IList<string>)oa1; // Exception
 >         IList<string> lst6 = (IList<string>)oa2; // Ok
 >
->         IReadOnlyList<string> lst7 = sa;                          // Ok
->         IReadOnlyList<string> lst8 = oa1;                         // Error, cast needed
->         IReadOnlyList<object> lst9 = sa;                          // Ok
->         IReadOnlyList<object> lst10 = oa1;                        // Ok
+>         IReadOnlyList<string> lst7 = sa;        // Ok
+>         IReadOnlyList<string> lst8 = oa1;       // Error, cast needed
+>         IReadOnlyList<object> lst9 = sa;        // Ok
+>         IReadOnlyList<object> lst10 = oa1;      // Ok
 >         IReadOnlyList<string> lst11 = (IReadOnlyList<string>)oa1; // Exception
 >         IReadOnlyList<string> lst12 = (IReadOnlyList<string>)oa2; // Ok
 >     }

standard/classes.md

@@ -12,8 +12,9 @@ A *class_declaration* is a *type_declaration* ([§13.7](namespaces.md#137-type-d
 
 ```ANTLR
 class_declaration
-  : attributes? class_modifier* 'partial'? 'class' identifier type_parameter_list?
-    class_base? type_parameter_constraints_clause* class_body ';'?
+  : attributes? class_modifier* 'partial'? 'class' identifier
+    type_parameter_list? class_base? type_parameter_constraints_clause*
+    class_body ';'?
   ;
 ```
 
@@ -213,9 +214,15 @@ The base class specified in a class declaration can be a constructed class type
 >
 > ```csharp
 > class Base<T> {}
-> class Extend : Base<int>     // Valid, non-constructed class with constructed base class
-> class Extend<V> : V {}       // Error, type parameter used as base class
-> class Extend<V> : Base<V> {} // Valid, type parameter used as type argument for base class
+>
+> // Valid, non-constructed class with constructed base class
+> class Extend : Base<int>
+>
+> // Error, type parameter used as base class
+> class Extend<V> : V {}
+>
+> // Valid, type parameter used as type argument for base class
+> class Extend<V> : Base<V> {}
 > ```
 >
 > *end example*
@@ -956,10 +963,10 @@ When a field, method, property, event, indexer, constructor, or finalizer declar
 >     static void Main()
 >     {
 >         Test t = new Test();
->         t.x = 1;             // Ok
->         t.y = 1;             // Error, cannot access static member through instance
->         Test.x = 1;          // Error, cannot access instance member through type
->         Test.y = 1;          // Ok
+>         t.x = 1;       // Ok
+>         t.y = 1;       // Error, cannot access static member through instance
+>         Test.x = 1;    // Error, cannot access instance member through type
+>         Test.y = 1;    // Ok
 >     }
 > }
 > ```
@@ -1214,10 +1221,10 @@ Every type declaration contained within a generic class declaration is implicitl
 >
 >     static void F(T t)
 >     {
->         Outer<T>.Inner<string>.F(t, "abc");         // These two statements have
->         Inner<string>.F(t, "abc");                  // the same effect
->         Outer<int>.Inner<string>.F(3, "abc");       // This type is different
->         Outer.Inner<string>.F(t, "abc");            // Error, Outer needs type arg
+>         Outer<T>.Inner<string>.F(t, "abc");    // These two statements have
+>         Inner<string>.F(t, "abc");             // the same effect
+>         Outer<int>.Inner<string>.F(3, "abc");  // This type is different
+>         Outer.Inner<string>.F(t, "abc");       // Error, Outer needs type arg
 >     }
 > }
 > ```
@@ -1620,7 +1627,8 @@ These restrictions ensure that all threads will observe volatile writes performe
 >         // Run Thread2() in a new thread
 >         new Thread(new ThreadStart(Thread2)).Start();    
 >
->         // Wait for Thread2() to signal that it has a result by setting finished to true.
+>         // Wait for Thread2() to signal that it has a result
+>         // by setting finished to true.
 >         for (;;)
 >         {
 >             if (finished)
@@ -1868,8 +1876,9 @@ method_declaration
     ;
 
 method_header
-    : attributes? method_modifier* 'partial'? return_type member_name type_parameter_list?
-      '(' formal_parameter_list? ')' type_parameter_constraints_clause*
+    : attributes? method_modifier* 'partial'? return_type member_name
+      type_parameter_list? '(' formal_parameter_list? ')'
+      type_parameter_constraints_clause*
     ;
 
 method_modifier
@@ -2239,9 +2248,14 @@ When performing overload resolution, a method with a parameter array might be ap
 > using System;
 > class Test
 > {
->     static void F(params object[] a)    => Console.WriteLine("F(object[])");
->     static void F()                     => Console.WriteLine("F()");>
->     static void F(object a0, object a1) => Console.WriteLine("F(object,object)");
+>     static void F(params object[] a) =>
+>         Console.WriteLine("F(object[])");
+>
+>     static void F() =>
+>         Console.WriteLine("F()");>
+>
+>     static void F(object a0, object a1) =>
+>         Console.WriteLine("F(object,object)");
 >
 >     static void Main()
 >     {
@@ -2501,16 +2515,16 @@ A compile-time error occurs unless all of the following are true for an override
 >
 > class D : C<string>
 > {
->     public override string F() {...}                // Ok
->     public override C<string> G() {...}             // Ok
->     public override void H(C<T> x) {...}            // Error, should be C<string>
+>     public override string F() {...}            // Ok
+>     public override C<string> G() {...}         // Ok
+>     public override void H(C<T> x) {...}        // Error, should be C<string>
 > }
 >
 > class E<T,U> : C<U>
 > {
->     public override U F() {...}                     // Ok
->     public override C<U> G() {...}                  // Ok
->     public override void H(C<T> x) {...}            // Error, should be C<U>
+>     public override U F() {...}                 // Ok
+>     public override C<U> G() {...}              // Ok
+>     public override void H(C<T> x) {...}        // Error, should be C<U>
 > }
 > ```
 >
@@ -3607,7 +3621,8 @@ Events are declared using *event_declaration*s:
 ```ANTLR
 event_declaration
   : attributes? event_modifier* 'event' type variable_declarators ';'
-  | attributes? event_modifier* 'event' type member_name '{' event_accessor_declarations '}'
+  | attributes? event_modifier* 'event' type member_name
+    '{' event_accessor_declarations '}'
   ;
 
 event_modifier
@@ -4125,7 +4140,8 @@ overloadable_unary_operator
   ;
 
 binary_operator_declarator
-  : type 'operator' overloadable_binary_operator '(' fixed_parameter ',' fixed_parameter ')'
+  : type 'operator' overloadable_binary_operator
+    '(' fixed_parameter ',' fixed_parameter ')'
   ;
 
 overloadable_binary_operator
@@ -4208,8 +4224,8 @@ The `true` and `false` unary operators require pair-wise declaration. A compile-
 >     {
 >         IntVector iv1 = new IntVector(4); // Vector of 4 x 0
 >         IntVector iv2;
->         iv2 = iv1++;                      // iv2 contains 4 x 0, iv1 contains 4 x 1
->         iv2 = ++iv1;                      // iv2 contains 4 x 2, iv1 contains 4 x 2
+>         iv2 = iv1++;              // iv2 contains 4 x 0, iv1 contains 4 x 1
+>         iv2 = ++iv1;              // iv2 contains 4 x 2, iv1 contains 4 x 2
 >     }
 > }
 > ```
@@ -4637,7 +4653,8 @@ A ***static constructor*** is a member that implements the actions required to i
 
 ```ANTLR
 static_constructor_declaration
-  : attributes? static_constructor_modifiers identifier '(' ')' static_constructor_body
+  : attributes? static_constructor_modifiers identifier '(' ')'
+    static_constructor_body
   ;
 
 static_constructor_modifiers
@@ -4796,8 +4813,10 @@ A ***finalizer*** is a member that implements the actions required to finalize a
 ```ANTLR
 finalizer_declaration
     : attributes? '~' identifier '(' ')' finalizer_body
-    | attributes? 'extern' unsafe_modifier? '~' identifier '(' ')' finalizer_body
-    | attributes? unsafe_modifier 'extern'? '~' identifier '(' ')' finalizer_body
+    | attributes? 'extern' unsafe_modifier? '~' identifier '(' ')'
+      finalizer_body
+    | attributes? unsafe_modifier 'extern'? '~' identifier '(' ')'
+      finalizer_body
     ;
 
 finalizer_body

standard/conversions.md

@@ -22,10 +22,18 @@ Some conversions in the language are defined from expressions to types, others f
 >
 > ```csharp
 > enum Color { Red, Blue, Green }
-> Color c0 = 0;        // The expression 0 converts implicitly to enum types
-> Color c1 = (Color)1; // other int expressions need explicit conversion
-> String x = null;     // Conversion from null expression (no type) to String
-> Func<int, int> square = x => x * x; // Conversion from lambda expression to delegate type
+>
+> // The expression 0 converts implicitly to enum types
+> Color c0 = 0;
+>
+> // Other int expressions need explicit conversion
+> Color c1 = (Color)1;
+>
+> // Conversion from null expression (no type) to String
+> String x = null;
+>
+> // Conversion from lambda expression to delegate type
+> Func<int, int> square = x => x * x;
 > ```
 >
 > *end example*