Doc Comments for Transformations

src/QsCompiler/Compiler/RewriteSteps/SyntaxTreeTrimming.cs

@@ -31,7 +31,7 @@ internal class SyntaxTreeTrimming : IRewriteStep
         public bool ImplementsPostconditionVerification => false;
 
         /// <summary>
-        /// Constructor for the SyntaxTreeTrimming Rewrite Step.
+        /// Initializes a new instance of the <see cref="SyntaxTreeTrimming"/> class.
         /// </summary>
         /// <param name="keepAllIntrinsics">When true, intrinsics will not be removed as part of the rewrite step.</param>
         public SyntaxTreeTrimming(bool keepAllIntrinsics = true, IEnumerable<QsQualifiedName>? dependencies = null)

src/QsCompiler/Transformations/MonomorphizationValidation.cs

@@ -10,8 +10,17 @@
 
 namespace Microsoft.Quantum.QsCompiler.Transformations.Monomorphization.Validation
 {
+    /// <summary>
+    /// Validates that the monomorphization transformation has removed all references to
+    /// generic objects.
+    /// </summary>
     public class ValidateMonomorphization : SyntaxTreeTransformation<ValidateMonomorphization.TransformationState>
     {
+        /// <summary>
+        /// Applies the transformation that walks through the syntax tree, checking to ensure
+        /// that all generic data has been removed. If allowTypeParametersForIntrinsics is true,
+        /// then generic data is allowed for type parameters of callables that have an intrinsic body.
+        /// </summary>
         public static void Apply(QsCompilation compilation, bool allowTypeParametersForIntrinsics = true)
         {
             var intrinsicCallableSet = allowTypeParametersForIntrinsics

src/QsCompiler/Transformations/SyntaxTreeTrimming.cs

@@ -11,8 +11,20 @@
 
 namespace Microsoft.Quantum.QsCompiler.Transformations.SyntaxTreeTrimming
 {
+    /// <summary>
+    /// Removes unused callables from the syntax tree.
+    /// </summary>
     public static class TrimSyntaxTree
     {
+        /// <summary>
+        /// Applies the transformation that removes from the syntax tree all callables that
+        /// are unused, meaning they are not a descendant of at least one entry point in
+        /// the call graph. If keepAllIntrinsics is true, callables with an intrinsic body
+        /// will not be trimmed, regardless of usage. Any callables that later
+        /// transformations will depend on should be passed in and will not be trimmed,
+        /// regardless of usage. Note that unused type constructors will be subject to
+        /// trimming as any other callable.
+        /// </summary>
         public static QsCompilation Apply(QsCompilation compilation, bool keepAllIntrinsics, IEnumerable<QsQualifiedName>? dependencies = null)
         {
             return TrimTree.Apply(compilation, keepAllIntrinsics, dependencies);
@@ -68,6 +80,9 @@ private static bool Filter(QsNamespaceElement elem, ImmutableHashSet<QsQualified
                 }
             }
 
+            /// <summary>
+            /// Class representing the state of the transformation.
+            /// </summary>
             public class TransformationState
             {
                 public Func<QsNamespaceElement, bool> NamespaceElementFilter { get; }