Update H1s to avoid duplication with vblang repo

spec/arrays.md

@@ -1,4 +1,4 @@
-# Arrays
+# Arrays - C# specification
 
 An array is a data structure that contains a number of variables which are accessed through computed indices. The variables contained in an array, also called the elements of the array, are all of the same type, and this type is called the element type of the array.
 

spec/attributes.md

@@ -1,4 +1,4 @@
-# Attributes
+# Attributes - C# specification
 
 Much of the C# language enables the programmer to specify declarative information about the entities defined in the program. For example, the accessibility of a method in a class is specified by decorating it with the *method_modifier*s `public`, `protected`, `internal`, and `private`.
 

spec/basic-concepts.md

@@ -1,4 +1,4 @@
-# Basic concepts
+# Basic concepts - C# specification
 
 ## Application Startup
 

spec/classes.md

@@ -1,4 +1,4 @@
-# Classes
+# Classes - C# specification
 
 A class is a data structure that may contain data members (constants and fields), function members (methods, properties, events, indexers, operators, instance constructors, destructors and static constructors), and nested types. Class types support inheritance, a mechanism whereby a derived class can extend and specialize a base class.
 

spec/conversions.md

@@ -1,4 +1,4 @@
-# Conversions
+# Conversions - C# specification
 
 A ***conversion*** enables an expression to be treated as being of a particular type. A conversion may cause an expression of a given type to be treated as having a different type, or it may cause an expression without a type to get a type. Conversions can be ***implicit*** or ***explicit***, and this determines whether an explicit cast is required. For instance, the conversion from type `int` to type `long` is implicit, so expressions of type `int` can implicitly be treated as type `long`. The opposite conversion, from type `long` to type `int`, is explicit and so an explicit cast is required.
 

spec/delegates.md

@@ -1,4 +1,4 @@
-# Delegates
+# Delegates - C# specification
 
 Delegates enable scenarios that other languages—such as C++, Pascal, and Modula -- have addressed with function pointers. Unlike C++ function pointers, however, delegates are fully object oriented, and unlike C++ pointers to member functions, delegates encapsulate both an object instance and a method.
 

spec/documentation-comments.md

@@ -1,4 +1,4 @@
-# Documentation comments
+# Documentation comments - C# specification
 
 C# provides a mechanism for programmers to document their code using a special comment syntax that contains XML text. In source code files, comments having a certain form can be used to direct a tool to produce XML from those comments and the source code elements, which they precede. Comments using such syntax are called ***documentation comments***. They must immediately precede a user-defined type (such as a class, delegate, or interface) or a member (such as a field, event, property, or method). The XML generation tool is called the ***documentation generator***. (This generator could be, but need not be, the C# compiler itself.) The output produced by the documentation generator is called the ***documentation file***. A documentation file is used as input to a ***documentation viewer***; a tool intended to produce some sort of visual display of type information and its associated documentation.
 

spec/enums.md

@@ -1,4 +1,4 @@
-# Enums
+# Enums - C# specification
 
 An ***enum type*** is a distinct value type ([Value types](types.md#value-types)) that declares a set of named constants.
 

spec/exceptions.md

@@ -1,4 +1,4 @@
-# Exceptions
+# Exceptions - C# specification
 
 Exceptions in C# provide a structured, uniform, and type-safe way of handling both system level and application level error conditions. The exception mechanism in C# is quite similar to that of C++, with a few important differences:
 

spec/expressions.md

@@ -1,4 +1,4 @@
-# Expressions
+# Expressions - C# specification
 
 An expression is a sequence of operators and operands. This chapter defines the syntax, order of evaluation of operands and operators, and meaning of expressions.
 

spec/interfaces.md

@@ -1,4 +1,4 @@
-# Interfaces
+# Interfaces - C# specification
 
 An interface defines a contract. A class or struct that implements an interface must adhere to its contract. An interface may inherit from multiple base interfaces, and a class or struct may implement multiple interfaces.
 

spec/introduction.md

@@ -1,4 +1,4 @@
-# Introduction
+# Introduction - C# specification
 
 C# (pronounced "See Sharp") is a simple, modern, object-oriented, and type-safe programming language. C# has its roots in the C family of languages and will be immediately familiar to C, C++, and Java programmers. C# is standardized by ECMA International as the ***ECMA-334*** standard and by ISO/IEC as the ***ISO/IEC 23270*** standard. Microsoft's C# compiler for the .NET Framework is a conforming implementation of both of these standards.
 

spec/lexical-structure.md

@@ -1,4 +1,4 @@
-# Lexical structure
+# Lexical structure - C# specification
 
 ## Programs
 

spec/namespaces.md

@@ -1,4 +1,4 @@
-# Namespaces
+# Namespaces - C# specification
 
 C# programs are organized using namespaces. Namespaces are used both as an "internal" organization system for a program, and as an "external" organization system—a way of presenting program elements that are exposed to other programs.
 

spec/statements.md

@@ -1,4 +1,4 @@
-# Statements
+# Statements - C# specification
 
 C# provides a variety of statements. Most of these statements will be familiar to developers who have programmed in C and C++.
 

spec/structs.md

@@ -1,4 +1,4 @@
-# Structs
+# Structs - C# specification
 
 Structs are similar to classes in that they represent data structures that can contain data members and function members. However, unlike classes, structs are value types and do not require heap allocation. A variable of a struct type directly contains the data of the struct, whereas a variable of a class type contains a reference to the data, the latter known as an object.
 

spec/types.md

@@ -1,4 +1,4 @@
-# Types
+# Types - C# specification
 
 The types of the C# language are divided into two main categories: ***value types*** and ***reference types***. Both value types and reference types may be ***generic types***, which take one or more ***type parameters***. Type parameters can designate both value types and reference types.
 
@@ -660,4 +660,3 @@ Two things are important to make explicit:
     ```
 
     After executing this code,  `i1` and `i2` will both have the value `2`.
-

spec/unsafe-code.md

@@ -1,4 +1,4 @@
-# Unsafe code
+# Unsafe code - C# specification
 
 The core C# language, as defined in the preceding chapters, differs notably from C and C++ in its omission of pointers as a data type. Instead, C# provides references and the ability to create objects that are managed by a garbage collector. This design, coupled with other features, makes C# a much safer language than C or C++. In the core C# language it is simply not possible to have an uninitialized variable, a "dangling" pointer, or an expression that indexes an array beyond its bounds. Whole categories of bugs that routinely plague C and C++ programs are thus eliminated.
 

spec/variables.md

@@ -1,4 +1,4 @@
-# Variables
+# Variables - C# specification
 
 Variables represent storage locations. Every variable has a type that determines what values can be stored in the variable. C# is a type-safe language, and the C# compiler guarantees that values stored in variables are always of the appropriate type. The value of a variable can be changed through assignment or through use of the `++` and `--` operators.
 
@@ -638,4 +638,3 @@ In C and C++, a *variable_reference* is known as an *lvalue*.
 ## Atomicity of variable references
 
 Reads and writes of the following data types are atomic: `bool`, `char`, `byte`, `sbyte`, `short`, `ushort`, `uint`, `int`, `float`, and reference types. In addition, reads and writes of enum types with an underlying type in the previous list are also atomic. Reads and writes of other types, including `long`, `ulong`, `double`, and `decimal`, as well as user-defined types, are not guaranteed to be atomic. Aside from the library functions designed for that purpose, there is no guarantee of atomic read-modify-write, such as in the case of increment or decrement.
-