Fixed escaping of const values

frog/value.dart

 // Copyright (c) 2011, 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.
 
 /**
  * Represents a meta-value for code generation.
  */
 class Value {
   /** The [Type] of the [Value]. */
   Type type;
@@ skipping 528 matching lines @@
     return new EvaluatedValue._internal(type, actualValue,
         canonicalCode, span, codeWithComments(canonicalCode, span));
   }
 
   EvaluatedValue._internal(Type type, this.actualValue, this.canonicalCode,
       SourceSpan span, String code)
     : super(type, code, span, false);
 
   static String codeWithComments(String canonicalCode, SourceSpan span) {
     return (span != null && span.text != canonicalCode)
-        ? '$canonicalCode/*${span.text}*/' : canonicalCode;
+        ? '$canonicalCode/*${_escapeForComment(span.text)}*/' : canonicalCode;
   }
 }
 
 /** An evaluated constant list expression. */
 class ConstListValue extends EvaluatedValue {
   List<EvaluatedValue> values;
 
   factory ConstListValue(Type type, List<EvaluatedValue> values,
       String actualValue, String canonicalCode, SourceSpan span) {
     return new ConstListValue._internal(type, values, actualValue,
@@ skipping 86 matching lines @@
   factory GlobalValue.fromStatic(field, Value exp, dependencies) {
     var code = (exp.isConst ? exp.canonicalCode : exp.code);
     var codeWithComment = '$code/*${field.declaringType.name}.${field.name}*/';
     return new GlobalValue(
         exp.type, codeWithComment, field.isFinal, field, null, exp,
         code, exp.span, dependencies.filter((d) => d is GlobalValue));
   }
 
   factory GlobalValue.fromConst(uniqueId, Value exp, dependencies) {
     var name = "const\$$uniqueId";
-    var codeWithComment = "$name/*${exp.span.text}*/";
+    var codeWithComment = "$name/*${_escapeForComment(exp.span.text)}*/";
     return new GlobalValue(
         exp.type, codeWithComment, true, null, name, exp, name,
         exp.span,
         dependencies.filter((d) => d is GlobalValue));
   }
 
   GlobalValue(Type type, String code, bool isConst,
       this.field, this.name, this.exp, this.canonicalCode,
       SourceSpan span, List<GlobalValue> _dependencies)
       : super(type, code, span, !isConst), dependencies = [] {
@@ skipping 64 matching lines @@
     // Then look for members in my library.
     member = home.library.lookup(name, span);
     if (member != null) {
       return member;
     }
 
     _ensureCode();
     return null;
   }
 }
+
+String _escapeForComment(String text) {
+  return text.replaceAll('/*', '/ *').replaceAll('*/', '* /');

[jimhug, 2011/12/02 00:16:00]

I think you need two more spaces to make this bullet proof.  I'd strongly
suggest just using ' * ' as the replacement.  With your current version, I think
these would break in the right/wrong positions:
/*/   */*

[Jennifer Messerly, 2011/12/02 00:24:23]

with the double replace,
"/ * /"
"* / *"

I don't feel 100% confident though with any of these, short of killing all / and
* from the string. (Maybe we should just get rid of the const-comments. I'm not
sure they're really worth it. Some complexity in GlobalValue/EvaluatedValue
would go away too)

+}