Add missing space in error message for missing constructor.

lib/compiler/implementation/ssa/builder.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.
 
 class Interceptors {
   Compiler compiler;
   Interceptors(Compiler this.compiler);
 
   SourceString mapOperatorToMethodName(Operator op) {
     String name = op.source.stringValue;
@@ skipping 1996 matching lines @@
 
   HInstruction generateInstanceSendReceiver(Send send) {
     assert(Elements.isInstanceSend(send, elements));
     if (send.receiver == null) {
       return localsHandler.readThis();
     }
     visit(send.receiver);
     return pop();
   }
 
-  String getTargetName(ErroneousElement error, [String prefix = '']) {
-    return '$prefix${error.targetName.slowToString()}';
+  String getTargetName(ErroneousElement error, [String prefix]) {
+    String result = error.targetName.slowToString();
+    if (?prefix) {
+      result = '$prefix $result';
+    }
+    return result;
   }
 
   void generateInstanceGetterWithCompiledReceiver(Send send,
                                                   HInstruction receiver) {
     assert(Elements.isInstanceSend(send, elements));
     // TODO(kasperl): This is a convoluted way of checking if we're
     // generating code for a compound assignment. If we are, we need
     // to get the selector from the mapping for the AST selector node.
     Selector selector = (send.asSendSet() === null)
         ? elements.getSelector(send)
@@ skipping 36 matching lines @@
     } else if (Elements.isInstanceSend(send, elements)) {
       HInstruction receiver = generateInstanceSendReceiver(send);
       generateInstanceGetterWithCompiledReceiver(send, receiver);
     } else if (Elements.isStaticOrTopLevelFunction(element)) {
       push(new HStatic(element));
       // TODO(ahe): This should be registered in codegen.
       compiler.enqueuer.codegen.registerGetOfStaticFunction(element);
     } else if (Elements.isErroneousElement(element)) {
       // An erroneous element indicates an unresolved static getter.
       generateThrowNoSuchMethod(send,
-                                getTargetName(element, 'get '),
+                                getTargetName(element, 'get'),
                                 const EmptyLink<Node>());
     } else {
       stack.add(localsHandler.readLocal(element));
     }
   }
 
   void generateInstanceSetterWithCompiledReceiver(Send send,
                                                   HInstruction receiver,
                                                   HInstruction value) {
     assert(Elements.isInstanceSend(send, elements));
@@ skipping 26 matching lines @@
         value = potentiallyCheckType(value, element);
         addWithPosition(new HStaticStore(element, value), send);
       }
       stack.add(value);
     } else if (element === null || Elements.isInstanceField(element)) {
       HInstruction receiver = generateInstanceSendReceiver(send);
       generateInstanceSetterWithCompiledReceiver(send, receiver, value);
     } else if (Elements.isErroneousElement(element)) {
       // An erroneous element indicates an unresolved static setter.
       generateThrowNoSuchMethod(send,
-                                getTargetName(element, 'set '),
+                                getTargetName(element, 'set'),
                                 send.arguments);
     } else {
       stack.add(value);
       // If the value does not already have a name, give it here.
       if (value.sourceElement === null) {
         value.sourceElement = element;
       }
       HInstruction checked = potentiallyCheckType(value, element);
       if (checked !== value) {
         pop();
@@ skipping 1062 matching lines @@
       if (node.declaredIdentifier.asSend() !== null) {
         variable = elements[node.declaredIdentifier];
       } else {
         assert(node.declaredIdentifier.asVariableDefinitions() !== null);
         VariableDefinitions variableDefinitions = node.declaredIdentifier;
         variable = elements[variableDefinitions.definitions.nodes.head];
       }
       HInstruction oldVariable = pop();
       if (variable.isErroneous()) {
         generateThrowNoSuchMethod(node,
-                                  getTargetName(variable, 'set '),
+                                  getTargetName(variable, 'set'),
                                   argumentValues: <HInstruction>[oldVariable]);
         pop();
       } else {
         localsHandler.updateLocal(variable, oldVariable);
       }
 
       visit(node.body);
     }
     handleLoop(node, buildInitializer, buildCondition, () {}, buildBody);
   }
@@ skipping 983 matching lines @@
           new HSubGraphBlockInformation(elseBranch.graph));
 
     HBasicBlock conditionStartBlock = conditionBranch.block;
     conditionStartBlock.setBlockFlow(info, joinBlock);
     SubGraph conditionGraph = conditionBranch.graph;
     HIf branch = conditionGraph.end.last;
     assert(branch is HIf);
     branch.blockInformation = conditionStartBlock.blockFlow;
   }
 }