Update handling of multiline strings to specification.

tests/language/multiline_newline_test.dart

 // Copyright (c) 2015, 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.
 
 import 'package:expect/expect.dart';
 import 'multiline_newline_cr.dart' as cr;
 import 'multiline_newline_crlf.dart' as crlf;
 import 'multiline_newline_lf.dart' as lf;
 
 main() {
   Expect.equals(4, cr.constantMultilineString.length);
   Expect.equals(4, crlf.constantMultilineString.length);
   Expect.equals(4, lf.constantMultilineString.length);
+
+  Expect.equals(6, cr.constantRawMultilineString.length);
+  Expect.equals(6, crlf.constantRawMultilineString.length);
+  Expect.equals(6, lf.constantRawMultilineString.length);
+
   Expect.equals(cr.constantMultilineString, crlf.constantMultilineString);
   Expect.equals(crlf.constantMultilineString, lf.constantMultilineString);
   Expect.equals(lf.constantMultilineString, cr.constantMultilineString);
 
+  Expect.equals(cr.constantRawMultilineString, crlf.constantRawMultilineString);
+  Expect.equals(crlf.constantRawMultilineString, lf.constantRawMultilineString);
+  Expect.equals(lf.constantRawMultilineString, cr.constantRawMultilineString);
+
   Expect.equals(4, cr.nonConstantMultilineString.length);
   Expect.equals(4, crlf.nonConstantMultilineString.length);
   Expect.equals(4, lf.nonConstantMultilineString.length);
+
+  Expect.equals(6, cr.nonConstantRawMultilineString.length);
+  Expect.equals(6, crlf.nonConstantRawMultilineString.length);
+  Expect.equals(6, lf.nonConstantRawMultilineString.length);
+
   Expect.equals(cr.nonConstantMultilineString, crlf.nonConstantMultilineString);
   Expect.equals(crlf.nonConstantMultilineString, lf.nonConstantMultilineString);
   Expect.equals(lf.nonConstantMultilineString, cr.nonConstantMultilineString);
 
+  Expect.equals(
+      cr.nonConstantRawMultilineString, crlf.nonConstantRawMultilineString);
+  Expect.equals(
+      crlf.nonConstantRawMultilineString, lf.nonConstantRawMultilineString);
+  Expect.equals(
+      lf.nonConstantRawMultilineString, cr.nonConstantRawMultilineString);
+
   const c1 =
       cr.constantMultilineString == crlf.constantMultilineString ? true : null;
   const c2 =
       crlf.constantMultilineString == lf.constantMultilineString ? true : null;
   const c3 =
       lf.constantMultilineString == cr.constantMultilineString ? true : null;
   Expect.isTrue(c1);
   Expect.isTrue(c2);
   Expect.isTrue(c3);
 
+  const c1r = cr.constantRawMultilineString == crlf.constantRawMultilineString
+      ? true
+      : null;

[Lasse Reichstein Nielsen, 2017/04/28 06:34:28]

Why the `? true : null` followed by `Expect.isTrue`. 
You can change null to false without changing the result, and then it's just the
same as not having the conditional operator at all.

So, suggestion: Remove the `? true : null`. Ditto everywhere, just change
.isNull to isFalse.

[Johnni Winther, 2017/04/28 07:12:00]

For analyzer testing. See lines 110-116

+  const c2r = crlf.constantRawMultilineString == lf.constantRawMultilineString
+      ? true
+      : null;
+  const c3r = lf.constantRawMultilineString == cr.constantRawMultilineString
+      ? true
+      : null;
+  Expect.isTrue(c1r);
+  Expect.isTrue(c2r);
+  Expect.isTrue(c3r);
+
   const c4 = c1 ? 1 : 2; // //# 01: ok
   Expect.equals(1, c4); //  //# 01: continued
 
   const c5 = c2 ? 2 : 3; // //# 02: ok
   Expect.equals(2, c5); //  //# 02: continued
 
   const c6 = c3 ? 3 : 4; // //# 03: ok
   Expect.equals(3, c6); //  //# 03: continued
 
+  const c4r = c1r ? 1 : 2; // //# 01r: ok
+  Expect.equals(1, c4r); //  //# 01r: continued

[Lasse Reichstein Nielsen, 2017/04/28 06:34:28]

Comment indentation off by one :) 
More below.

[ahe, 2017/04/28 07:39:00]

Acknowledged.

[ahe, 2017/05/08 08:36:17]

Done.

+
+  const c5r = c2r ? 2 : 3; // //# 02r: ok
+  Expect.equals(2, c5r); //  //# 02r: continued
+
+  const c6r = c3r ? 3 : 4; // //# 03r: ok
+  Expect.equals(3, c6r); //  //# 03r: continued
+
   const c7 =
       cr.constantMultilineString != crlf.constantMultilineString ? true : null;
   const c8 =
       crlf.constantMultilineString != lf.constantMultilineString ? true : null;
   const c9 =
       lf.constantMultilineString != cr.constantMultilineString ? true : null;
   Expect.isNull(c7);
   Expect.isNull(c8);
   Expect.isNull(c9);
 
+  const c7r = cr.constantRawMultilineString != crlf.constantRawMultilineString
+      ? true
+      : null;
+  const c8r = crlf.constantRawMultilineString != lf.constantRawMultilineString
+      ? true
+      : null;
+  const c9r = lf.constantRawMultilineString != cr.constantRawMultilineString
+      ? true
+      : null;
+  Expect.isNull(c7r);
+  Expect.isNull(c8r);
+  Expect.isNull(c9r);
+
   const c10 = c7 ? 1 : 2; // //# 04: compile-time error

[Lasse Reichstein Nielsen, 2017/04/28 06:34:28]

What is this testing? That `null` cannot be used as a conditional operator
condition in a const expression? That seems cute, but not really on-topic for
this test. 

[Johnni Winther, 2017/04/28 07:12:01]

This is to validate the analyzer implementation. It doesn't 'run' the code
unless it is in constants.

[ahe, 2017/04/28 07:39:00]

Not only does this validate the analyzer implementation, it also tests dart2js'
compile-time constant evaluation which is implemented differently from its
runtime evaluation.

[Lasse Reichstein Nielsen, 2017/04/28 08:57:36]

So the null is there to force a compile-time error below, which a bool wouldn't
do, and it's the only way to get a visible result out of the analyzer?

It's still feels a little (too) clever, but I can see the reasoning.
Just switching the values around to only get a compile-time error for an
incorrect implementation isn't as visible, it could hide that the entire program
was garbage collected instead.

[Johnni Winther, 2017/04/28 09:19:43]

We should probably add a comment about the intent of these compile-time errors.

[ahe, 2017/05/08 08:36:17]

Done.

   const c11 = c8 ? 2 : 3; // //# 05: compile-time error
   const c12 = c9 ? 3 : 4; // //# 06: compile-time error
+
+  const c10r = c7r ? 1 : 2; // //# 04r: compile-time error
+  const c11r = c8r ? 2 : 3; // //# 05r: compile-time error
+  const c12r = c9r ? 3 : 4; // //# 06r: compile-time error
 }