Merge branch 'master' into type-links

Author: mdparker

articles/code_coverage.dd

@@ -34,13 +34,15 @@ $(LI It can be used to track down why a particular section of code
 
 $(LI Since execution counts are given for each line, it is possible
      to use the coverage analysis to reorder the basic blocks in
-     a function to minimize jmps in the most used path, thus
-     optimizing it.)
-)
+     a function to minimize branches in the most used path, reducing stress
+     on the processor's pipeline (a run-of-the-mill X86 processor can usually handle 48 branches in its pipeline). This technique
+     is a special case of $(LINK2 https://en.wikipedia.org/wiki/Profile-guided_optimization, profile-guided optimization), which can
+     be performed automatically if either the `LLVM` or `GCC` backend is utilized.
+))
 
 $(P Experience with code coverage analyzers show that they dramatically
 reduce the number of bugs in shipping code.
-But it isn't a panacea, a code coverage analyzer won't help with:)
+But it isn't a panacea, a code coverage analyzer won't help (unlike Valgrind or the sanitizers available in GCC and LLVM) with:)
 
 $(OL
 $(LI Identifying race conditions.)
@@ -51,18 +53,18 @@ $(LI Verifying that the program got the correct result.)
 
 $(P Code coverage analysers are available for many popular languages,
 but they are often third party products that integrate
-poorly with the compiler, and are often very expensive.
+poorly with the compiler.
 A big problem with third party products is, in order to instrument
-the source code, they must include what is essentially a full blown
+the source code, they must include what is essentially a full-blown
 compiler front end for the same language. Not only is this an expensive
 proposition, it often winds up out of step with the various compiler
 vendors as their implementations change and as they evolve various extensions.
 ($(LINK2 http://gcc.gnu.org/onlinedocs/gcc-3.0/gcc_8.html, gcov),
-the Gnu coverage analyzer, is an exception as it is both free
+the Gnu coverage analyzer is an exception as it is both free
 and is integrated into gcc.)
 )
 
-$(P The D code coverage analyser is built in as part of the D compiler.
+$(P The D code coverage analyser is part of the D compiler.
 Therefore, it is always in perfect synchronization with the language
 implementation. It's implemented by establishing a counter for each
 line in each module compiled with the $(DDSUBLINK dmd,switch-cov, $(B -cov)) switch.
@@ -78,7 +80,7 @@ $(P For example, consider the Sieve program:)
 
 import std.stdio;
 
-bool flags[8191];
+bool[8191] flags;
 
 int main()
 {
@@ -124,7 +126,7 @@ $(CONSOLE
        |
        |import std.stdio;
        |
-       |bool flags[8191];
+       |bool[8191] flags;
        |
        |int main()
        |{
@@ -163,13 +165,13 @@ as the execution count.
 At the end of the .lst file, the percent coverage is given.
 )
 
-$(P There are 3 lines with an exection count
+$(P There are 3 lines with an execution count
 of 1, these were each executed once. The declaration line for $(D i, prime),
 etc., has 5 because there are 5 declarations, and the initialization of
 each declaration counts as one statement.)
 
 $(P The first $(D for) loop shows 22. This is the sum of the 3 parts
-of the for header. If the for header is broken up into 3 lines, the
+of the for-header. If the for-header is broken up into 3 lines, the
 data is similarly divided:)
 
 $(CONSOLE
@@ -263,7 +265,7 @@ sieve --DRT-covopt="merge:1 dstpath:reports"
 
 $(H3 References)
 
-$(LINK2 https://en.wikipedia.org/wiki/Code_coverage, Wikipedia)
+$(LINK2 https://en.wikipedia.org/wiki/Code_coverage, Wikipedia: "Code Coverage")
 
 )
 

comparison.dd

@@ -67,7 +67,7 @@ $(ITEMIZE
                 $(A spec/template-mixin.html, Mixins),
                 $(A spec/version.html#staticif, static if),
                 $(A spec/expression.html#IsExpression, expressions),
-                $(A spec/declaration.html#Typeof, typeof),
+                $(A spec/type.html#Typeof, typeof),
                 $(A spec/statement.html#ForeachStatement, foreach),
                 $(A spec/declaration.html#AutoDeclaration, Implicit Type Inference)
         ),

spec/expression.dd

@@ -1377,7 +1377,7 @@ $(GNAME PrimaryExpression):
     $(GLINK2 declaration, FundamentalType) $(D $(LPAREN)) $(GLINK ArgumentList)$(OPT) $(D $(RPAREN))
     $(GLINK2 type, TypeCtor) $(D $(LPAREN)) $(GLINK Type) $(D $(RPAREN)) $(D .) $(IDENTIFIER)
     $(GLINK2 type, TypeCtor) $(D $(LPAREN)) $(GLINK Type) $(D $(RPAREN)) $(D $(LPAREN)) $(GLINK ArgumentList)$(OPT) $(D $(RPAREN))
-    $(GLINK2 declaration, Typeof)
+    $(GLINK2 type, Typeof)
     $(GLINK TypeidExpression)
     $(GLINK IsExpression)
     $(D $(LPAREN)) $(GLINK Expression) $(D $(RPAREN))

spec/lex.dd

@@ -1016,7 +1016,7 @@ $(MULTICOLS 4,
     $(LINK2 type.html, $(D true))
     $(LINK2 statement.html#TryStatement, $(D try))
     $(LINK2 expression.html#TypeidExpression, $(D typeid))
-    $(LINK2 declaration.html#Typeof, $(D typeof))
+    $(LINK2 type.html#Typeof, $(D typeof))
 
     $(LINK2 type.html, $(D ubyte))
     $(LINK2 type.html, $(D ucent))

spec/template-mixin.dd

@@ -18,7 +18,7 @@ $(GNAME TemplateMixin):
 $(GNAME MixinTemplateName):
     $(D .) $(GLINK MixinQualifiedIdentifier)
     $(GLINK MixinQualifiedIdentifier)
-    $(GLINK2 declaration, Typeof) $(D .) $(GLINK MixinQualifiedIdentifier)
+    $(GLINK2 type, Typeof) $(D .) $(GLINK MixinQualifiedIdentifier)
 
 $(GNAME MixinQualifiedIdentifier):
     $(GLINK_LEX Identifier)

spec/type.dd

@@ -26,8 +26,8 @@ $(GNAME BasicType):
     $(GLINK FundamentalType)
     $(D .) $(GLINK QualifiedIdentifier)
     $(GLINK QualifiedIdentifier)
-    $(GLINK2 declaration, Typeof)
-    $(GLINK declaration, Typeof) $(D .) $(GLINK QualifiedIdentifier)
+    $(GLINK Typeof)
+    $(GLINK Typeof) $(D .) $(GLINK QualifiedIdentifier)
     $(GLINK TypeCtor) $(D $(LPAREN)) $(GLINK Type) $(D $(RPAREN))
     $(GLINK Vector)
     $(GLINK2 grammar, Traits)
@@ -540,18 +540,20 @@ $(GNAME MixinType):
         ---
 
 
-$(H2 $(LNAME2 size_t, $(D size_t)))
+$(H2 $(LNAME2 aliased-types, Aliased Types))
+
+$(H3 $(LNAME2 size_t, $(D size_t)))
 
     $(P $(D size_t) is an alias to one of the unsigned integral basic types,
     and represents a type that is large enough to represent an offset into
     all addressable memory.)
 
-$(H2 $(LNAME2 ptrdiff_t, $(D ptrdiff_t)))
+$(H3 $(LNAME2 ptrdiff_t, $(D ptrdiff_t)))
     $(P $(D ptrdiff_t) is an alias to the signed integral basic type the same size as $(D size_t).)
 
-$(H2 $(LNAME2 string, $(D string)))
+$(H3 $(LNAME2 string, $(D string)))
 
-    $(P A $(DDSUBLINK spec/arrays, strings, $(I string) is a special case of an arrays.))
+    $(P A $(DDSUBLINK spec/arrays, strings, $(I string) is a special case of an array.))
 
 $(SPEC_SUBNAV_PREV_NEXT declaration, Declarations, property, Properties)
 )