Update H1s to avoid duplication with csharplang repo

spec/attributes.md

@@ -1,4 +1,4 @@
-# Attributes
+# Attributes - Visual Basic specifications
 
 The Visual Basic language enables the programmer to specify modifiers on declarations, which represent information about the entities being declared. For example, affixing a class method with the modifiers `Public`, `Protected`, `Friend`, `Protected Friend`, or `Private` specifies its accessibility.
 
@@ -360,4 +360,4 @@ AttributeArgumentExpression
     | GetTypeExpression
     | ArrayExpression
     ;
-```
+```

spec/conversions.md

@@ -1,4 +1,4 @@
-# Conversions
+# Conversions - Visual Basic specifications
 
 Conversion is the process of changing a value from one type to another. For example, a value of type `Integer` can be converted to a value of type `Double`, or a value of type `Derived` can be converted to a value of type `Base`, assuming that `Base` and `Derived` are both classes and `Derived` inherits from `Base`. Conversions may not require the value itself to change (as in the latter example), or they may require significant changes in the value representation (as in the former example).
 

spec/documentation-comments.md

@@ -1,4 +1,4 @@
-# Documentation Comments
+# Documentation Comments - Visual Basic specifications
 
 Documentation comments are specially formatted comments in the source that can be analyzed to produce documentation about the code they are attached to. The basic format for documentation comments is XML. When the compiling code with documentation comments, the compiler may optionally emit an XML file that represents the sum total of the documentation comments in the source. This XML file can then be used by other tools to produce printed or online documentation.
 

spec/expressions.md

@@ -1,4 +1,4 @@
-# Expressions
+# Expressions - Visual Basic specifications
 
 An expression is a sequence of operators and operands that specifies a computation of a value, or that designates a variable or constant. This chapter defines the syntax, order of evaluation of operands and operators, and meaning of expressions.
 

spec/general-concepts.md

@@ -1,4 +1,4 @@
-# General Concepts
+# General Concepts - Visual Basic specifications
 
 This chapter covers a number of concepts that are required to understand the semantics of the Microsoft Visual Basic language. Many of the concepts should be familiar to Visual Basic programmers or C/C++ programmers, but their precise definitions may differ.
 

spec/introduction.md

@@ -1,4 +1,4 @@
-# Introduction
+# Introduction - Visual Basic specifications
 
 The Microsoft® Visual Basic® programming language is a high-level programming language for the Microsoft .NET Framework. Although it is designed to be an approachable and easy-to-learn language, it is also powerful enough to satisfy the needs of experienced programmers. The Visual Basic programming language has a syntax that is similar to English, which promotes the clarity and readability of Visual Basic code. Wherever possible, meaningful words or phrases are used instead of abbreviations, acronyms, or special characters. Extraneous or unneeded syntax is generally allowed but not required.
 

spec/lexical-grammar.md

@@ -1,4 +1,4 @@
-# Lexical Grammar
+# Lexical Grammar - Visual Basic specifications
 
 Compilation of a Visual Basic program first involves translating the raw stream of Unicode characters into an ordered set of lexical tokens. Because the Visual Basic language is not free-format, the set of tokens is then further divided into a series of logical lines. A *logical line* spans from either the start of the stream or a line terminator through to the next line terminator that is not preceded by a line continuation or through to the end of the stream.
 

spec/overload-resolution.md

@@ -1,4 +1,4 @@
-# Overloaded Method Resolution
+# Overloaded Method Resolution - Visual Basic specifications
 
 In practice, the rules for determining overload resolution are intended to find the overload that is "closest" to the actual arguments supplied. If there is a method whose parameter types match the argument types, then that method is obviously the closest. Barring that, one method is closer than another if all of its parameter types are narrower than (or the same as) the parameter types of the other method. If neither method's parameters are narrower than the other, then there is no way for to determine which method is closer to the arguments.
 

spec/preprocessing-directives.md

@@ -1,4 +1,4 @@
-# Preprocessing Directives
+# Preprocessing Directives - Visual Basic specifications
 
 Once a file has been lexically analyzed, several kinds of source preprocessing occur. The most important, conditional compilation, determines which source is processed by the syntactic grammar; two other types of directives -- external source directives and region directives -- provide meta-information about the source but have no effect on compilation.
 

spec/source-files-and-namespaces.md

@@ -1,4 +1,4 @@
-# Source Files and Namespaces
+# Source Files and Namespaces - Visual Basic specifications
 
 A Visual Basic program consists of one or more source files. When a program is compiled, all of the source files are processed together; thus, source files can depend on each other, possibly in a circular fashion, without any forward-declaration requirement. The textual order of declarations in the program text is generally of no significance.
 

spec/statements.md

@@ -1,4 +1,4 @@
-# Statements
+# Statements - Visual Basic specifications
 
 Statements represent executable code.
 

spec/type-members.md

@@ -1,4 +1,4 @@
-# Type Members
+# Type Members - Visual Basic specifications
 
 Type members define storage locations and executable code. They can be methods, constructors, events, constants, variables, and properties.
 

spec/types.md

@@ -1,4 +1,4 @@
-# Types
+# Types - Visual Basic specifications
 
 The two fundamental categories of types in Visual Basic are *value types* and *reference types*. Primitive types (except strings), enumerations, and structures are value types. Classes, strings, standard modules, interfaces, arrays, and delegates are reference types.