markdown fixes

Author: mairaw

proposals/caller-argument-expression.md

@@ -15,7 +15,7 @@ Allow developers to capture the expressions passed to a method, to enable better
 
 When an assertion or argument validation fails, the developer wants to know as much as possible about where and why it failed. However, today's diagnostic APIs do not fully facilitate this. Consider the following method:
 
-```cs
+```csharp
 T Single<T>(this T[] array)
 {
     Debug.Assert(array != null);
@@ -31,7 +31,7 @@ This is also the reason testing frameworks have to provide a variety of assert m
 
 While the situation is a bit better for argument validation because the names of invalid arguments are shown to the developer, the developer must pass these names to exceptions manually. If the above example were rewritten to use traditional argument validation instead of `Debug.Assert`, it would look like
 
-```cs
+```csharp
 T Single<T>(this T[] array)
 {
     if (array == null)
@@ -55,7 +55,7 @@ Notice that `nameof(array)` must be passed to each exception, although it's alre
 
 In the above examples, including the string `"array != null"` or `"array.Length == 1"` in the assert message would help the developer determine what failed. Enter `CallerArgumentExpression`: it's an attribute the framework can use to obtain the string associated with a particular method argument. We would add it to `Debug.Assert` like so
 
-```cs
+```csharp
 public static class Debug
 {
     public static void Assert(bool condition, [CallerArgumentExpression("condition")] string message = null);
@@ -64,7 +64,7 @@ public static class Debug
 
 The source code in the above example would stay the same. However, the code the compiler actually emits would correspond to
 
-```cs
+```csharp
 T Single<T>(this T[] array)
 {
     Debug.Assert(array != null, "array != null");
@@ -78,7 +78,7 @@ The compiler specially recognizes the attribute on `Debug.Assert`. It passes the
 
 For argument validation, the attribute cannot be used directly, but can be made use of through a helper class:
 
-```cs
+```csharp
 public static class Verify
 {
     public static void Argument(bool condition, string message, [CallerArgumentExpression("condition")] string conditionExpression = null)
@@ -137,7 +137,7 @@ A proposal to add such a helper class to the framework is underway at https://gi
 
 The `this` parameter in an extension method may be referenced by `CallerArgumentExpression`. For example:
 
-```cs
+```csharp
 public static void ShouldBe<T>(this T @this, T expected, [CallerArgumentExpression("this")] string thisExpression = null) {}
 
 contestant.Points.ShouldBe(1337); // thisExpression: "contestant.Points"
@@ -167,7 +167,7 @@ There should always be an expression corresponding to the `this` parameter. Even
 - If being able to see source code at call sites for methods that use this attribute proves to be a problem, we can make the attribute's effects opt-in. Developers will enable it through an assembly-wide `[assembly: EnableCallerArgumentExpression]` attribute they put in `AssemblyInfo.cs`.
   - In the case the attribute's effects are not enabled, calling methods marked with the attribute would not be an error, to allow existing methods to use the attribute and maintain source compatibility. However, the attribute would be ignored and the method would be called with whatever default value was provided.
 
-```cs
+```csharp
 // Assembly1
 
 void Foo(string bar); // V1
@@ -189,7 +189,7 @@ Foo(a, "provided"); // V2, V3: Compiles to Foo(a, "provided")
 
 - To prevent the [binary compatibility problem][drawbacks] from occurring every time we want to add new caller info to `Debug.Assert`, an alternative solution would be to add a `CallerInfo` struct to the framework that contains all the necessary information about the caller.
 
-```cs
+```csharp
 struct CallerInfo
 {
     public string MemberName { get; set; }

proposals/covariant-returns.md

@@ -50,7 +50,7 @@ The implementation of this would be for the compiler to emit the overriding meth
 
 We could relax the language rules slightly to allow, in source,
 
-``` c#
+```csharp
 abstract class Cloneable
 {
     public abstract Cloneable Clone();
@@ -77,5 +77,4 @@ class Digit : Cloneable
 
 ## Design meetings
 
-None yet. There has been some discussion at https://github.com/dotnet/roslyn/issues/357
-
+None yet. There has been some discussion at <https://github.com/dotnet/roslyn/issues/357>.

proposals/declaration-expressions.md

@@ -6,13 +6,15 @@ Support declaration assignments as expressions.
 [motivation]: #motivation
 
 Allow initialization at the point of declaration in more cases, simplifying code, and allowing `var` to be used.
-```C#
+
+```csharp
 SpecialType ReferenceType =>
     (var st = _type.SpecialType).IsValueType() ? SpecialType.None : st;
 ```
 
 Allow declarations for `ref` arguments, similar to `out var`.
-```C#
+
+```csharp
 Convert(source, destination, ref List<Diagnostic> diagnostics = null);
 ```
 
@@ -48,7 +50,8 @@ the expression is a copy.
 The declaration assignment expression may declare a `ref` local.
 There is an ambiguity when `ref` is used for a declaration expression in a `ref` argument.
 The local variable initializer determines whether the declaration is a `ref` local.
-```C#
+
+```csharp
 F(ref int x = IntFunc());    // int x;
 F(ref int y = RefIntFunc()); // ref int y;
 ```