Update headings to use sentence case.

sdk/lib/_internal/compiler/implementation/patch_parser.dart

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 /**
  * This library contains the infrastructure to parse and integrate patch files.
  *
  * Three types of elements can be patched: [LibraryElement], [ClassElement],
  * [FunctionElement]. Patches are introduced in patch libraries which are loaded
  * together with the corresponding origin library. Which libraries that are
  * patched is determined by the dart2jsPatchPath field of LibraryInfo found
  * in [:lib/_internal/libraries.dart:].
  *
  * Patch libraries are parsed like regular library and thus provided with their
  * own elements. These elements which are distinct from the elements from the
  * patched library and the relation between patched and patch elements is
  * established through the [:patch:] and [:origin:] fields found on
  * [LibraryElement], [ClassElement] and [FunctionElement]. The [:patch:] fields
  * are set on the patched elements to point to their corresponding patch
  * element, and the [:origin:] elements are set on the patch elements to point
  * their corresponding patched elements.
  *
  * The fields [Element.isPatched] and [Element.isPatch] can be used to determine
  * whether the [:patch:] or [:origin:] field, respectively, has been set on an
  * element, regardless of whether the element is one of the three patchable
  * element types or not.
  *
- * ## Variants of Classes and Functions ##
+ * ## Variants of classes and functions ##
  *
  * With patches there are four variants of classes and function:
  *
  * Regular: A class or function which is not declared in a patch library and
  *   which has no corresponding patch.
  * Origin: A class or function which is not declared in a patch library and
  *   which has a corresponding patch. Origin functions must use the [:external:]
  *   modifier and can have no body. Origin classes and functions are also
  *   called 'patched'.
  * Patch: A class or function which is declared in a patch library and which
@@ skipping 21 matching lines @@
  *     // In the patch library:
  *     class _InjectedClass { // An injected class.
  *       void _injectedMethod() {} // An injected method.
  *     }
  *     patch class PatchedClass { // A patch class.
  *       int _injectedField; { // An injected field.
  *       patch void patchedMethod() {} // A patch method.
  *     }
  *
  *
- * ## Declaration and Implementation ##
+ * ## Declaration and implementation ##
  *
  * With patches we have two views on elements: as the 'declaration' which
  * introduces the entity and defines its interface, and as the 'implementation'
  * which defines the actual implementation of the entity.
  *
  * Every element has a 'declaration' and an 'implementation' element. For
  * regular and injected elements these are the same. For origin elements the
  * declaration is the element itself and the implementation is the patch element
  * found through its [:patch:] field. For patch elements the implementation is
  * the element itself and the declaration is the origin element found through
@@ skipping 468 matching lines @@
 
 // TODO(johnniwinther): Add unittest when patch is (real) metadata.
 bool isPatchElement(Element element) {
   // TODO(lrn): More checks needed if we introduce metadata for real.
   // In that case, it must have the identifier "native" as metadata.
   for (Link link = element.metadata; !link.isEmpty; link = link.tail) {
     if (link.head is PatchMetadataAnnotation) return true;
   }
   return false;
 }