Add missing Rakudo warnings to MOP type docs, move to top of page

Kaiepi · Kaiepi · commit 8934227813f9 · 2020-01-11T22:37:56.000-04:00
diff --git a/doc/Type/Metamodel/AttributeContainer.pod6 b/doc/Type/Metamodel/AttributeContainer.pod6
@@ -6,6 +6,9 @@
 
     role Metamodel::AttributeContainer {}
 
+I<Warning>: this role is part of the Rakudo implementation, and is not
+a part of the language specification.
+
 Classes, roles and grammars can have attributes. Storage and introspection of
 attributes is implemented by this role.
 
diff --git a/doc/Type/Metamodel/C3MRO.pod6 b/doc/Type/Metamodel/C3MRO.pod6
@@ -6,6 +6,9 @@
 
     role Metamodel::C3MRO { }
 
+I<Warning>: this role is part of the Rakudo implementation, and is not
+a part of the language specification.
+
 L<Metamodel|/language/mop> role for the
 L<I<C3> method resolution order (MRO)|https://en.wikipedia.org/wiki/C3_linearization>.
 I<Note>: this method,
diff --git a/doc/Type/Metamodel/ClassHOW.pod6 b/doc/Type/Metamodel/ClassHOW.pod6
@@ -29,14 +29,14 @@
         does Metamodel::Finalization
             { }
 
+I<Warning>: this class is part of the Rakudo implementation, and is not
+a part of the language specification.
+
 C<Metamodel::ClassHOW> is the metaclass behind the C<class> keyword.
 
     say so Int.HOW ~~ Metamodel::ClassHOW;    # OUTPUT: «True␤»
     say Int.^methods(:all).pick.name;         # OUTPUT: «random Int method name␤»
 
-I<Warning>: This class is part of the Rakudo implementation, not a part of the
-language itself.
-
 =head1 Methods
 
 =head2 method add_fallback
diff --git a/doc/Type/Metamodel/ConcreteRoleHOW.pod6 b/doc/Type/Metamodel/ConcreteRoleHOW.pod6
@@ -16,6 +16,9 @@
         does Metamodel::ArrayType
         does Metamodel::Concretization {}
 
+I<Warning>: this class is part of the Rakudo implementation, and is not
+a part of the language specification.
+
 You can use this to build roles, in the same way that C<ClassHOW> can be used to
 build classes:
 
diff --git a/doc/Type/Metamodel/CurriedRoleHOW.pod6 b/doc/Type/Metamodel/CurriedRoleHOW.pod6
@@ -9,6 +9,9 @@
         does Metamodel::TypePretense
         does Metamodel::RolePunning {}
 
+I<Warning>: this class is part of the Rakudo implementation, and is not
+a part of the language specification.
+
 Sometimes, we see references to roles that provide parameters but
 do not fully resolve them. For example, in:
 
diff --git a/doc/Type/Metamodel/Documenting.pod6 b/doc/Type/Metamodel/Documenting.pod6
@@ -6,6 +6,9 @@
 
     role Metamodel::Documenting { }
 
+I<Warning>: this role is part of the Rakudo implementation, and is not
+a part of the language specification.
+
 Type declarations may include declarator blocks (C<#|> and C<#=>), which allow
 you to set the type's documentation. This can then be accessed through the
 C<WHY> method on objects of that type:
@@ -47,9 +50,6 @@ through their HOW like this, as C<Metamodel::Documenting>'s methods are
 exposed through L<Mu|/type/Mu> via its C<WHY> and C<set_why> methods,
 which are usable on types in most cases.
 
-I<Warning>: This role is part of the Rakudo implementation, not a part
-of the language itself.
-
 =head1 Methods
 
 =head2 method set_why
diff --git a/doc/Type/Metamodel/EnumHOW.pod6 b/doc/Type/Metamodel/EnumHOW.pod6
@@ -22,6 +22,9 @@
         does Metamodel::Mixins
             { }
 
+I<Warning>: this class is part of the Rakudo implementation, and is not
+a part of the language specification.
+
 C<Metamodel::EnumHOW> is the metaclass behind the C<enum> keyword.
 
     enum Numbers <1 2>;
@@ -49,9 +52,6 @@ Is roughly equivalent to this code using C<Metamodel::EnumHOW>'s methods:
         OUR::<Error> := Error;
     }
 
-I<Warning>: This class is part of the Rakudo implementation, and is not a part
-of the language specification.
-
 =head1 Methods
 
 =head2 method new_type
diff --git a/doc/Type/Metamodel/Finalization.pod6 b/doc/Type/Metamodel/Finalization.pod6
@@ -8,6 +8,9 @@ X<|DESTROY metamodel>
 
     role Metamodel::Finalization { ... }
 
+I<Warning>: this role is part of the Rakudo implementation, and is not
+a part of the language specification.
+
 This role takes care that C<DESTROY> submethods are called (if they
 exist) when an object is garbage-collected.
 
diff --git a/doc/Type/Metamodel/MROBasedMethodDispatch.pod6 b/doc/Type/Metamodel/MROBasedMethodDispatch.pod6
@@ -6,6 +6,9 @@
 
     role Metamodel::MROBasedMethodDispatch { }
 
+I<Warning>: this role is part of the Rakudo implementation, and is not
+a part of the language specification.
+
 This role implements locating methods based on the method resolution order of
 related (usually "super"/"parent") types.
 
diff --git a/doc/Type/Metamodel/MethodContainer.pod6 b/doc/Type/Metamodel/MethodContainer.pod6
@@ -6,7 +6,10 @@
 
     role Metamodel::MethodContainer {}
 
-roles, classes, grammars and enums can contain methods. This role implements
+I<Warning>: this role is part of the Rakudo implementation, and is not
+a part of the language specification.
+
+Roles, classes, grammars and enums can contain methods. This role implements
 the API around storing and introspecting them.
 
     say .name for Int.^methods(:all);
diff --git a/doc/Type/Metamodel/MultipleInheritance.pod6 b/doc/Type/Metamodel/MultipleInheritance.pod6
@@ -6,6 +6,9 @@
 
     role Metamodel::MultipleInheritance {}
 
+I<Warning>: this role is part of the Rakudo implementation, and is not
+a part of the language specification.
+
 Classes, roles and grammars can have parent classes, that is, classes to which
 method lookups fall back to, and to whose type the child class conforms to.
 
diff --git a/doc/Type/Metamodel/Naming.pod6 b/doc/Type/Metamodel/Naming.pod6
@@ -6,6 +6,9 @@
 
     role Metamodel::Naming { }
 
+I<Warning>: this role is part of the Rakudo implementation, and is not
+a part of the language specification.
+
 L<Metamodel|/language/mop> role for (optionally) named things, like classes,
 roles and enums.
 
diff --git a/doc/Type/Metamodel/PackageHOW.pod6 b/doc/Type/Metamodel/PackageHOW.pod6
@@ -11,14 +11,14 @@
       does Metamodel::TypePretense
       does Metamodel::MethodDelegation { }
 
-C<Metamodel::ClassHOW> is the metaclass behind the C<package> keyword.
+I<Warning>: this class is part of the Rakudo implementation, and is not
+a part of the language specification.
+
+C<Metamodel::PackageHOW> is the metaclass behind the C<package> keyword.
 
     package P {};
     say P.HOW; # OUTPUT: «Perl6::Metamodel::PackageHOW.new␤»
 
-I<Warning>: This class is part of the Rakudo implementation, not a part of the
-language itself.
-
 =head1 Methods
 
 =head2 method archetypes
diff --git a/doc/Type/Metamodel/ParametricRoleGroupHOW.pod6 b/doc/Type/Metamodel/ParametricRoleGroupHOW.pod6
@@ -12,6 +12,9 @@
         does Metamodel::RolePunning
         does Metamodel::BoolificationProtocol {}
 
+I<Warning>: this role is part of the Rakudo implementation, and is not
+a part of the language specification.
+
 A C<ParametricRoleGroupHOW> groups a set of C<ParametricRoleHOW>, every one of them representing a single role declaration with their own parameter sets.
 
 =for code
@@ -25,7 +28,6 @@ my \zape := Metamodel::ParametricRoleGroupHOW.new_type( name => "zape");
 my \zipi := Metamodel::ParametricRoleHOW.new_type( name => "zipi", group => zape);
 say zipi.HOW; # OUTPUT: «Perl6::Metamodel::ParametricRoleHOW.new␤»
 
-
 I<Note>: As most of the C<Metamodel> classes, this class is here mainly for
 illustration purposes and it's not intended for the final user to instantiate.
 
diff --git a/doc/Type/Metamodel/ParametricRoleHOW.pod6 b/doc/Type/Metamodel/ParametricRoleHOW.pod6
@@ -19,6 +19,9 @@
         does Metamodel::RolePunning
         does Metamodel::ArrayType {}
 
+I<Warning>: this class is part of the Rakudo implementation, and is not
+a part of the language specification.
+
 A C<Metamodel::ParametricRoleHOW> represents a non-instantiated, possibly
 parameterized, role:
 
diff --git a/doc/Type/Metamodel/PrivateMethodContainer.pod6 b/doc/Type/Metamodel/PrivateMethodContainer.pod6
@@ -6,6 +6,9 @@
 
     role Metamodel::PrivateMethodContainer { ... }
 
+I<Warning>: this role is part of the Rakudo implementation, and is not
+a part of the language specification.
+
 In Raku, classes, roles and grammars can have private methods, that is,
 methods that are only callable from within the class, and are not inherited by
 types derived by inheritance.
diff --git a/doc/Type/Metamodel/RoleContainer.pod6 b/doc/Type/Metamodel/RoleContainer.pod6
@@ -6,6 +6,9 @@
 
     role Metamodel::RoleContainer {}
 
+I<Warning>: this role is part of the Rakudo implementation, and is not
+a part of the language specification.
+
 Implements the ability to hold roles to be held for composition.
 
 =for code :preamble<role SomeRole {}>
diff --git a/doc/Type/Metamodel/RolePunning.pod6 b/doc/Type/Metamodel/RolePunning.pod6
@@ -6,6 +6,9 @@
 
     role Perl6::Metamodel::RolePunning {}
 
+I<Warning>: this role is part of the Rakudo implementation, and is not
+a part of the language specification.
+
 Implements the ability to create objects from C<Role>s without the intermediate
 need to use a class. Not intended to be used directly (will in fact error if
 it's C<use>d), but via punning of roles, as below. This is also Rakudo specific
diff --git a/doc/Type/Metamodel/Stashing.pod6 b/doc/Type/Metamodel/Stashing.pod6
@@ -6,6 +6,9 @@
 
     role Metamodel::Stashing { }
 
+I<Warning>: this role is part of the Rakudo implementation, and is not
+a part of the language specification.
+
 Types may have a stash associated with them, which is a named hash
 containing our-scoped symbols for that type's package. When this is
 the case, they can be used like namespaces; you can get their stash
@@ -27,9 +30,6 @@ setting a stash object for types. Types used with this metarole are
 expected to support naming, so when writing custom HOWs that do it,
 ensure they also do L<Metamodel::Naming|/type/Metamodel::Naming>.
 
-I<Warning>: This role is part of the Rakudo implementation, not a part
-of the language itself.
-
 =head1 Methods
 
 =head2 method add_stash
diff --git a/doc/Type/Metamodel/Trusting.pod6 b/doc/Type/Metamodel/Trusting.pod6
@@ -7,6 +7,9 @@
 =for code :preamble<class SuperClass {};>
 role Metamodel::Trusting is SuperClass { ... }
 
+I<Warning>: this role is part of the Rakudo implementation, and is not
+a part of the language specification.
+
 Normally, code in a class or role can only access its own private methods. If
 another type declares that it trusts that first class, then access to private
 methods of that second type is possible. C<Metamodel::Trusting> implements
diff --git a/doc/Type/Metamodel/Versioning.pod6 b/doc/Type/Metamodel/Versioning.pod6
@@ -6,6 +6,9 @@
 
    role Metamodel::Versioning { ... }
 
+I<Warning>: this role is part of the Rakudo implementation, and is not
+a part of the language specification.
+
 L<Metamodel|/language/mop> role for (optionally) versioning metaobjects.
 
 When you declare a type, you can pass it a version, author, and/or API and get
