Dev compiler merge

.gitattributes

@@ -27,6 +27,9 @@ tests/lib/mirrors/method_mirror_source_line_ending_crlf.dart -text
 tests/lib/mirrors/method_mirror_source_line_ending_lf.dart -text
 tests/lib/mirrors/method_mirror_source_test.dart -text
 tests/lib/mirrors/method_mirror_source_other.dart -text
+pkg/dev_compiler/test/codegen/language/multiline_newline_crlf.dart -text
+pkg/dev_compiler/test/codegen/lib/mirrors/method_mirror_source_line_ending_cr.dart -text
+pkg/dev_compiler/test/codegen/lib/mirrors/method_mirror_source_line_ending_crlf.dart -text
 
 # Files to leave alone and not diff.
 *.png binary

DEPS

@@ -56,7 +56,6 @@ vars = {
   "dart_services_rev" : "@7aea2574e6f3924bf409a80afb8ad52aa2be4f97",
   "dart_style_tag": "@0.2.9+1",
   "dartdoc_tag" : "@v0.9.7+2",
-  "dev_compiler_rev": "@01d4907cff61ecf934940e7243f79ef68e4bb12b",
   "fixnum_tag": "@0.10.5",
   "func_rev": "@8d4aea75c21be2179cb00dc2b94a71414653094e",
   "glob_rev": "@704cf75e4f26b417505c5c611bdaacd8808467dd",
@@ -201,8 +200,6 @@ deps = {
       (Var("github_mirror") % "dart2js_info") + Var("dart2js_info_rev"),
   Var("dart_root") + "/third_party/pkg/dartdoc":
       (Var("github_mirror") % "dartdoc") + Var("dartdoc_tag"),
-  Var("dart_root") + "/third_party/pkg/dev_compiler":
-      (Var("github_mirror") % "dev_compiler") + Var("dev_compiler_rev"),
   Var("dart_root") + "/third_party/pkg/func":
       (Var("github_dartlang") % "func") + Var("func_rev"),
   Var("dart_root") + "/third_party/pkg/fixnum":

pkg/dev_compiler/.analysis_options

@@ -0,0 +1,10 @@
+analyzer:
+  strong-mode: true
+  exclude:
+    - doc/api/**
+    - gen/**
+    - node_modules/**
+    - tool/input_sdk/**
+    - test/codegen/**
+    - test/samples/**
+    - test/transformer/hello_app/**

pkg/dev_compiler/.gitignore

@@ -0,0 +1,24 @@
+# Don’t commit the following files and directories created by pub.
+.pub
+build/
+packages
+.packages
+
+# Ignore files created by tools.
+*.dart.precompiled.js
+*.js_
+*.js.deps
+*.sw?
+.idea/
+.pub/
+node_modules
+doc/api/
+
+# Generated files go here.
+gen/
+
+# Ignore generated SDK summary.
+lib/js/*/*.sum
+
+# Created by ./tool/dependency_overrides.sh.
+dependency_overrides/

pkg/dev_compiler/.travis.yml

@@ -0,0 +1,33 @@
+language: dart
+sudo: false
+dart:
+  - dev
+cache:
+  directories:
+    - $HOME/.npm
+    - $HOME/.nvm
+    - $HOME/.pub-cache/hosted
+    - node_modules
+before_install:
+  - test "$ANALYZER" != master -a "$ANALYZER" != dev || ./tool/override_analyzer_dependency.sh $ANALYZER
+  - pub global activate dart_coveralls
+  - export CHROME_CANARY_BIN=`./tool/get_chrome_canary.sh`
+  - export DISPLAY=:99.0
+  - sh -e /etc/init.d/xvfb start
+before_script:
+  - nvm install 5.5.0
+  - npm install
+script:
+  - if [[ -z "$TEST" ]]; then ./tool/presubmit.sh ; fi
+  - if [[ "$TEST" == coverage ]]; then ./tool/build_sdk.sh && ./tool/coverage.sh ; fi
+  - if [[ "$TEST" == node ]]; then ./tool/node_test.sh ; fi
+env:
+  - ANALYZER=stable
+  - ANALYZER=master
+  - ANALYZER=dev
+  - TEST=coverage
+  - TEST=node
+matrix:
+  allow_failures:
+    - env: ANALYZER=master
+    - env: TEST=node

pkg/dev_compiler/CHANGELOG.md

@@ -0,0 +1,71 @@
+# dev_compiler changelog
+
+## next release
+- add support for AMD modules and make it the default.
+- precompile the SDK in AMD, CommonJS, and ES6 flavors.
+- legacy module format is deprecated.
+
+## 0.1.24
+- workaround breaking change on requestAnimationFrame
+
+## 0.1.23
+- updates for the latest analyzer
+- removal of deprecated functionality (server mode) in prep for refactoring
+
+## 0.1.22
+- fixes to support the latest analyzer
+- improvements in compile speed
+- bug fixes on function / closure handling
+
+## 0.1.21
+- bug fix for dart:js constructor invocation
+
+## 0.1.20
+- support new StackTrace.current method
+
+## 0.1.19
+- support for dom libraries (dart:html, etc)
+
+## 0.1.18
+- dart:typed_data support
+- preliminary TS / Closure output support
+- various runtime typing fixes
+
+## 0.1.17
+- preliminary node module support
+- support for compiling / serving multiple html files
+
+## 0.1.16
+- rolled analyzer to 0.27.2-alpha.1
+- fixes for static fields
+
+## 0.1.15
+- codegen fixes for dart:convert (json decode) and dart:math (max, min)
+
+## 0.1.14
+- updates to unpin analyzer and move forward to ^0.27.1+2
+
+## 0.1.13
+- various fixes in js codegen
+- pinned to analyzer 0.26.2+1 to avoid breaking upstream changes
+
+## 0.1.12
+- fixes for babel
+- fixes toward new js interop
+
+## 0.1.11
+- moved js runtime files to lib/runtime/dart (`dart_runtime.js` -> `dart/_runtime.js`)
+- bug fix to source maps
+- initial support for f-bound quantification patterns
+
+## 0.1.10
+- added an `--html-report` option to create a file summarizing compilation
+  issues
+- added a `-f` alias to the `--force-compile` command line option
+- removed many info level messages that were informational to the DDC team
+
+## 0.1.9
+
+## 0.1.8
+- added a `--version` command-line option
+- added a new entry-point - `dev_compiler` - that aliases to `dartdevc`

pkg/dev_compiler/LICENSE.md

@@ -0,0 +1,35 @@
+This license applies to all files contained here with the following
+exceptions:
+
+- All code in test/js_test_tools is externally maintained with
+  corresponding licenses in those individual files and directories.
+
+---
+
+Copyright 2015, the Dart project authors. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above
+      copyright notice, this list of conditions and the following
+      disclaimer in the documentation and/or other materials provided
+      with the distribution.
+    * Neither the name of Google Inc. nor the names of its
+      contributors may be used to endorse or promote products derived
+      from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

pkg/dev_compiler/README.md

@@ -0,0 +1,31 @@
+dev_compiler
+============
+
+[![Build Status](https://travis-ci.org/dart-lang/dev_compiler.svg?branch=master)](https://travis-ci.org/dart-lang/dev_compiler)
+[![Coverage Status](https://coveralls.io/repos/dart-lang/dev_compiler/badge.svg?branch=master)](https://coveralls.io/r/dart-lang/dev_compiler)
+
+The Dart Dev Compiler (DDC) is an **experimental** development tool and transpiler.  It is at a very early stage today.  Its aims include the following:
+
+- A static checker based on stricter-than-standard-Dart type rules.
+- A modular Dart-to-ES6 transpiler for Dart programs that statically check.
+
+DDC attempts to map to idiomatic EcmaScript 6 (ES6) as cleanly as possible.  To do this while cohering to Dart semantics, DDC relies heavily on static type information, static checking, and runtime assertions.
+
+DDC is intended to support a very [large subset](https://github.com/dart-lang/dev_compiler/blob/master/STRONG_MODE.md) of Dart.  If a program does not statically check, DDC will not result in valid generated code.  Our goal is that a program execution (of a valid program) that runs without triggering runtime assertions should run the same on other Dart platforms under checked mode or production mode.
+
+DDC does support untyped Dart code, but it will typically result in less readable and less efficient ES6 output.
+
+DDC has the following project goals:
+
+- Effective static checking and error detection.
+- A debugging solution for all modern browsers.
+- Readable output.
+- Fast, modular compilation of Dart code.
+- Easy use of generated code from JavaScript.
+
+DDC is still in a very early stage as highlighted by our choice of ES6.  ES6 itself is in active development across all modern browsers, but at various stages of support:
+[kangax.github.io/compat-table/es6](https://kangax.github.io/compat-table/es6/).
+
+We are targeting the subset of ES6 supported in Chrome.
+
+To try out DDC and/or give feedback, please read our [usage](https://github.com/dart-lang/dev_compiler/blob/master/USAGE.md) page.

pkg/dev_compiler/STRONG_MODE.md

@@ -0,0 +1,58 @@
+# Strong Mode
+
+Strong mode applies a more restrictive type system to Dart to address its unsound, surprising behavior in certain cases.
+
+Strong mode helps with:
+
+- [Stronger static checking](doc/STATIC_SAFETY.md) to find more errors during static analysis or compilation.
+  - This includes a [prototype of generic methods](doc/GENERIC_METHODS.md) for better expressiveness and checking.
+- [Stronger runtime checking](doc/RUNTIME_SAFETY.md) in the Dart Dev Compiler (DDC) to find errors at runtime.
+- [Idiomatic JavaScript code generation](doc/JS_CODEGEN.md) via DDC for more readable output and better interoperability.
+
+## Motivation
+
+Strong mode aims to ensure that static type annotations are actually correct at runtime.  For this to work, strong mode provides a stricter type system than standard Dart.  Consider the following example:
+
+```dart
+// util.dart
+
+void info(List<int> list) {
+  var length = list.length;
+  if (length != 0) print(length + list[0]);
+}
+```
+
+A developer might reasonably expect the `info` function to print either nothing (empty list) or a single integer (non-empty list), and that Dart’s static tooling and checked mode would enforce this.
+
+However, in the following context, the info method prints “helloworld” in checked mode, without any static errors or warnings:
+
+```dart
+import ‘dart:collection’;
+import ‘util.dart’;
+
+class MyList extends ListBase<int> implements List {
+   Object length;
+
+   MyList(this.length);
+
+   operator[](index) => "world";
+   operator[]=(index, value) {}
+}
+
+void main() {
+   List<int> list = new MyList("hello");
+   info(list);
+}
+```
+
+The lack of static or runtime errors in the Dart specification's type rules is not an oversight; it is by design.  It provides developers a mechanism to circumvent or ignore types when convenient, but it comes at cost.  While the above example is contrived, it demonstrates that developers cannot easily reason about a program modularly: the static type annotations in the `util` library are of limited use, even in checked mode.
+
+For the same reason, a compiler cannot easily exploit type annotations if they are unsound.  A Dart compiler cannot simply assume that a `List<int>` contains `int` values or even that its `length` is an integer.  Instead, it must either rely on expensive (and often brittle) whole program analysis or on additional runtime checking.  That [additional checking](doc/JS_CODEGEN.md) may lead to larger, slower code and harder-to-read output when Dart is transpiled to a high level language like JavaScript.
+
+The fundamental issue above is that static annotations may not match runtime types, even in checked mode: this is a direct consequence of the unsoundness of the Dart type system.  This can make it difficult for both programmers and compilers to rely on static types to reason about programs.
+
+Strong mode solves that by enforcing the correctness of static type annotations.  It disallows examples such as the above. In this example, standard Dart rules (checked or otherwise) allow `MyList` to masquerade as a `List<int>`.  Strong mode statically rejects the declaration of `MyList`.
+
+DDC augments strong mode static checking with a minimal set of runtime checks required to enforce soundness, similar to how Java and C# handle potentially unsafe casts.  This allows both the developer and the compiler to better reason about the info method.  For statically checked code, both may assume that the argument is a proper `List<int>`, with integer-valued length and elements.
+
+DDC execution is stricter than checked mode.  A Dart program execution where (a) the program passes DDC’s static checking and (b) the execution does not trigger DDC’s runtime assertions, will also run in checked mode on any Dart platform.

pkg/dev_compiler/USAGE.md

@@ -0,0 +1,81 @@
+# Usage
+
+The [Dart Dev Compiler](README.md) (DDC) is an **experimental**
+development compiler from Dart to EcmaScript 6.  It is
+still incomplete, under heavy development, and not yet ready for
+production use.
+
+With those caveats, we welcome feedback for those experimenting.
+
+The easiest way to compile and run DDC generated code for now is via NodeJS.  The following instructions are in a state of flux - please expect them to change.  If you find issues, please let us know.
+
+(1) Clone the [DDC repository](https://github.com/dart-lang/dev_compiler) and set the environment variable DDC_PATH to your checkout.
+
+(2) Install nodejs v6.0 or later and add it to your path.  It can be installed from:
+
+https://nodejs.org/
+
+Note, v6 or later is required for harmony / ES6 support.
+
+(3) Create a node compatible version of the dart_sdk:
+
+```
+dart $DDC_PATH/tool/build_sdk.dart --dart-sdk $DDC_PATH/gen/patched_sdk/ --modules node -o dart_sdk.js
+```
+
+You can ignore any errors or warnings for now.
+
+(4) Define a node path (you can add other directories if you want to separate things out):
+
+```
+export NODE_PATH=.
+```
+
+(5) Compile a test file with a `main` entry point:
+
+```
+dart  $DDC_PATH/bin/dartdevc.dart --modules node -o hello.js hello.dart
+```
+
+Note, the `hello.js` built here is not fully linked.  It loads the SDK via a `require` call.
+
+(6) Run it via your node built in step 1:
+
+```
+node -e 'require("hello").hello.main()'
+```
+
+(7) Compile multiple libraries using summaries.  E.g., write a `world.dart` that imports `hello.dart` with it's own `main`.  Step 5 above generated a summary (`hello.sum`) for `hello.dart`.  Build world:
+
+```
+dart $DDC_PATH/bin/dartdevc.dart --modules node -s hello.sum -o world.js world.dart
+```
+
+Run world just like hello above:
+
+```
+node -e 'require("world").world.main()'
+```
+
+(8) Node modules do not run directly on the browser or v8.  You can use a tool like `browserify` to build a linked javascript file that can:
+
+Install:
+```
+sudo npm install -g browserify
+```
+
+and run, e.g.,:
+```
+echo 'require("world").world.main()' | browserify -d - > world.dart.js
+```
+
+The produced `world.dart.js` fully links all dependencies (`dart_sdk`, `hello`, and `world`) and executes `world.main`.  It can be loaded via script tag and run in Chrome (stable or later).
+
+## Feedback
+
+Please file issues in our [GitHub issue tracker](https://github.com/dart-lang/dev_compiler/issues).
+
+You can also view or join our [mailing list](https://groups.google.com/a/dartlang.org/forum/#!forum/dev-compiler).
+
+
+