Roll Messages centralization back out.

community/kernel/src/main/java/org/neo4j/kernel/impl/proc/FieldInjections.java

@@ -30,11 +30,8 @@
 import org.neo4j.kernel.api.exceptions.ProcedureException;
 import org.neo4j.kernel.api.exceptions.Status;
 import org.neo4j.kernel.api.proc.CallableProcedure;
-import org.neo4j.messages.Messages;
 import org.neo4j.procedure.Context;
 
-import static org.neo4j.messages.Messages.proc_static_field_annotated_as_context;
-
 /**
  * Injects annotated fields with appropriate values.
  */
@@ -98,8 +95,10 @@ public List<FieldSetter> setters( Class<?> cls ) throws ProcedureException
                     if( field.isAnnotationPresent( Context.class ))
                     {
                         throw new ProcedureException( Status.Procedure.FailedRegistration,
-                                Messages.get( proc_static_field_annotated_as_context,
-                                        field.getName(), cls.getSimpleName() ) );
+                                "The field `%s` in the class named `%s` is annotated as a @Context field,\n" +
+                                "but it is static. @Context fields must be public, non-final and non-static,\n" +
+                                "because they are reset each time a procedure is invoked.",
+                                field.getName(), cls.getSimpleName() );
                     }
                     continue;
                 }

community/kernel/src/main/java/org/neo4j/kernel/impl/proc/MethodSignatureCompiler.java

@@ -28,13 +28,8 @@
 import org.neo4j.kernel.api.exceptions.ProcedureException;
 import org.neo4j.kernel.api.exceptions.Status;
 import org.neo4j.kernel.api.proc.ProcedureSignature.FieldSignature;
-import org.neo4j.messages.Messages;
 import org.neo4j.procedure.Name;
 
-import static org.neo4j.messages.Messages.proc_argument_missing_name;
-import static org.neo4j.messages.Messages.proc_argument_name_empty;
-import static org.neo4j.messages.Messages.proc_unmappable_argument_type;
-
 /**
  * Given a java method, figures out a valid {@link org.neo4j.kernel.api.proc.ProcedureSignature} field signature.
  * Basically, it takes the java signature and spits out the same signature described as Neo4j types.
@@ -61,15 +56,18 @@ public List<FieldSignature> signatureFor( Method method ) throws ProcedureExcept
             if ( !param.isAnnotationPresent( Name.class ) )
             {
                 throw new ProcedureException( Status.Procedure.FailedRegistration,
-                        Messages.get( proc_argument_missing_name, i, method.getName(),
-                        Name.class.getSimpleName()) );
+                        "Argument at position %d in method `%s` is missing an `@%s` annotation.\n" +
+                        "Please add the annotation, recompile the class and try again.",
+                        i, method.getName(), Name.class.getSimpleName() );
             }
             String name = param.getAnnotation( Name.class ).value();
 
             if( name.trim().length() == 0 )
             {
                 throw new ProcedureException( Status.Procedure.FailedRegistration,
-                        Messages.get( proc_argument_name_empty, i, method.getName() ) );
+                        "Argument at position %d in method `%s` is annotated with a name,\n" +
+                        "but the name is empty, please provide a non-empty name for the argument.",
+                        i, method.getName() );
             }
 
             try
@@ -79,9 +77,10 @@ public List<FieldSignature> signatureFor( Method method ) throws ProcedureExcept
             catch ( ProcedureException e )
             {
                 throw new ProcedureException( e.status(),
-                        Messages.get( proc_unmappable_argument_type,
-                            name, i, method.getName(), param.getType().getSimpleName(),
-                            e.getMessage() ) );
+                        "Argument `%s` at position %d in `%s` with\n" +
+                        "type `%s` cannot be converted to a Neo4j type: %s",
+                        name, i, method.getName(), param.getType().getSimpleName(),
+                        e.getMessage() );
             }
 
         }

community/kernel/src/main/java/org/neo4j/kernel/impl/proc/OutputMappers.java

@@ -33,13 +33,11 @@
 import org.neo4j.kernel.api.exceptions.Status;
 import org.neo4j.kernel.api.proc.ProcedureSignature;
 import org.neo4j.kernel.api.proc.ProcedureSignature.FieldSignature;
-import org.neo4j.messages.Messages;
 
 import static java.lang.reflect.Modifier.isPublic;
 import static java.lang.reflect.Modifier.isStatic;
 import static java.util.Arrays.asList;
 import static java.util.stream.Collectors.toList;
-import static org.neo4j.messages.Messages.proc_invalid_return_type_description;
 
 /**
  * Takes user-defined record classes, and does two things: Describe the class as a {@link ProcedureSignature}, and provide a mechanism to convert
@@ -136,8 +134,7 @@ public OutputMapper mapper( Method method ) throws ProcedureException
 
         if ( cls != Stream.class )
         {
-            throw new ProcedureException( Status.Procedure.TypeError,
-                    Messages.get( proc_invalid_return_type_description, cls.getSimpleName() ));
+            throw invalidReturnType( cls );
         }
 
         ParameterizedType genType = (ParameterizedType) method.getGenericReturnType();
@@ -193,11 +190,24 @@ private void assertIsValidRecordClass( Class<?> userClass ) throws ProcedureExce
         if( userClass.isPrimitive() || userClass.isArray()
             || userClass.getPackage() != null && userClass.getPackage().getName().startsWith( "java." ) )
         {
-            throw new ProcedureException( Status.Procedure.TypeError,
-                    Messages.get( proc_invalid_return_type_description, userClass.getSimpleName() ));
+            throw invalidReturnType( userClass );
         }
     }
 
+    private ProcedureException invalidReturnType( Class<?> userClass )
+    {
+        return new ProcedureException( Status.Procedure.TypeError,
+                "Procedures must return a Stream of records, where a record is a concrete class\n" +
+                "that you define, with public non-final fields defining the fields in the record.\n" +
+                "If you''d like your procedure to return `%s`, you could define a record class like:\n" +
+                "public class Output '{'\n" +
+                "    public %s out;\n" +
+                "'}'\n" +
+                "\n" +
+                "And then define your procedure as returning `Stream<Output>`.",
+                userClass.getSimpleName(), userClass.getSimpleName());
+    }
+
     private List<Field> instanceFields( Class<?> userClass )
     {
         return asList( userClass.getDeclaredFields() ).stream()

community/kernel/src/main/java/org/neo4j/kernel/impl/proc/TypeMappers.java

@@ -29,7 +29,6 @@
 import org.neo4j.kernel.api.exceptions.ProcedureException;
 import org.neo4j.kernel.api.exceptions.Status;
 import org.neo4j.kernel.api.proc.Neo4jTypes.AnyType;
-import org.neo4j.messages.Messages;
 
 import static org.neo4j.kernel.api.proc.Neo4jTypes.NTAny;
 import static org.neo4j.kernel.api.proc.Neo4jTypes.NTBoolean;
@@ -39,7 +38,6 @@
 import static org.neo4j.kernel.api.proc.Neo4jTypes.NTMap;
 import static org.neo4j.kernel.api.proc.Neo4jTypes.NTNumber;
 import static org.neo4j.kernel.api.proc.Neo4jTypes.NTString;
-import static org.neo4j.messages.Messages.proc_unmappable_type;
 
 public class TypeMappers
 {
@@ -146,7 +144,9 @@ private ProcedureException javaToNeoMappingError( Type cls )
         types.sort( (a,b)->a.toString().compareTo( b.toString() ) );
 
         return new ProcedureException( Status.Statement.InvalidType,
-                Messages.get( proc_unmappable_type, cls, types ));
+                "Don't know how to map `%s` to the Neo4j Type System.\n" +
+                "Please refer to to the documentation for full details.\n" +
+                "For your reference, known types are: %s", cls, types );
     }
 
     public static class SimpleConverter implements NeoValueConverter