implement private members, fixes #74

lib/src/codegen/js_codegen.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.
 
 library ddc.src.codegen.js_codegen;
 
 import 'dart:io' show Directory, File;
 
 import 'package:analyzer/analyzer.dart' hide ConstantEvaluator;
 import 'package:analyzer/src/generated/ast.dart' hide ConstantEvaluator;
@@ skipping 27 matching lines @@
 
   /// The variable for the target of the current `..` cascade expression.
   SimpleIdentifier _cascadeTarget;
 
   ClassDeclaration currentClass;
   ConstantEvaluator _constEvaluator;
 
   final _exports = <String>[];
   final _lazyFields = <VariableDeclaration>[];
   final _properties = <FunctionDeclaration>[];
+  final _privateNames = new Set<String>();

[Jennifer Messerly, 2015/03/02 18:48:16]

hmmm, another thought ... we could emit these as we go ... so they end up not
all at the top of the file. That might make the code feel a bit more natural?

 
   JSCodegenVisitor(LibraryInfo libraryInfo, TypeRules rules)
       : libraryInfo = libraryInfo,
         rules = rules,
         _libraryName = jsLibraryName(libraryInfo.library);
 
   Element get currentLibrary => libraryInfo.library;
 
   JS.Block generateLibrary(
       Iterable<CompilationUnit> units, CheckerReporter reporter) {
@@ skipping 10 matching lines @@
     }
 
     if (_exports.isNotEmpty) body.add(js.comment('Exports:'));
 
     // TODO(jmesserly): make these immutable in JS?
     for (var name in _exports) {
       body.add(js.statement('#.# = #;', [_libraryName, name, name]));
     }
 
     var name = _libraryName;
+    var symbolInit = _privateNames.map(_initPrivateSymbol);
     return new JS.Block([
       js.statement('var #;', name),
-      js.statement('''
-        (function (#) {
-          'use strict';
-          #;
-        })(# || (# = {}));
-      ''', [name, body, name, name])
+      js.statement("(function (#) { 'use strict'; #; #; })(# || (# = {}));",
+          [name, symbolInit, body, name, name])
     ]);
   }
 
+  JS.Statement _initPrivateSymbol(String name) =>
+      js.statement('let # = Symbol(#);', [name, js.string(name, "'")]);
+
   @override
   JS.Statement visitCompilationUnit(CompilationUnit node) {
     // TODO(jmesserly): scriptTag, directives.
     var body = <JS.Statement>[];
     for (var child in node.declarations) {
       // Attempt to group adjacent fields/properties.
       if (child is! TopLevelVariableDeclaration) _flushLazyFields(body);
       if (child is! FunctionDeclaration) _flushLibraryProperties(body);
 
       var code = _visit(child);
@@ skipping 296 matching lines @@
     return new JS.Block(body)..sourceInformation = node;
   }
 
   @override
   JS.Statement visitRedirectingConstructorInvocation(
       RedirectingConstructorInvocation node) {
     ClassDeclaration classDecl = node.parent.parent;
     var className = classDecl.name.name;
 
     var name = _constructorName(className, node.constructorName);
-    return js.statement('this.#(#);', [name, _visit(node.argumentList)]);
+    return js.statement('this.#(#);',
+        [_jsMemberName(name), _visit(node.argumentList)]);
   }
 
   JS.Statement _superConstructorCall(ClassDeclaration clazz,
       [SuperConstructorInvocation node]) {
     var superCtorName = node != null ? node.constructorName : null;
 
     var element = clazz.element;
     if (superCtorName == null &&
         (element.type.isObject || element.supertype.isObject)) {
       return null;
@@ skipping 29 matching lines @@
         }
       }
     }
 
     // Initialize fields from `this.fieldName` parameters.
     if (parameters != null) {
       for (var p in parameters.parameters) {
         if (p is DefaultFormalParameter) p = p.parameter;
         if (p is FieldFormalParameter) {
           var name = p.identifier.name;
-          body.add(js.statement('this.# = #;', [name, name]));
+          body.add(js.statement('this.# = #;',
+              [_jsMemberName(name), _visit(p)]));
           unsetFields.remove(name);
         }
       }
     }
 
     // Run constructor field initializers such as `: foo = bar.baz`
     if (initializers != null) {
       for (var init in initializers) {
         if (init is ConstructorFieldInitializer) {
           body.add(js.statement(
               '# = #;', [_visit(init.fieldName), _visit(init.expression)]));
           unsetFields.remove(init.fieldName.name);
         }
       }
     }
 
     // Initialize all remaining fields
     unsetFields.forEach((name, field) {
       JS.Expression value;
       if (field.initializer != null) {
         value = _visit(field.initializer);
       } else {
         var type = rules.elementType(field.element);
         if (rules.maybeNonNullableType(type)) {
           value = js.call('dart.as(null, #)', _emitTypeName(type));
         } else {
           value = new JS.LiteralNull();
         }
       }
-      body.add(js.statement('this.# = #;', [name, value]));
+      body.add(js.statement('this.# = #;', [_jsMemberName(name), value]));
     });
 
     return _statement(body);
   }
 
   FormalParameterList _parametersOf(node) {
     // Note: ConstructorDeclaration is intentionally skipped here so we can
     // emit the argument initializers in a different place.
     // TODO(jmesserly): clean this up. If we can model ES6 spread/rest args, we
     // could handle argument initializers more consistently in a separate
@@ skipping 47 matching lines @@
 
   @override
   JS.Method visitMethodDeclaration(MethodDeclaration node) {
     if (node.isAbstract || _externalOrNative(node)) {
       return null;
     }
 
     var params = _visit(node.parameters);
     if (params == null) params = [];
 
-    return new JS.Method(new JS.PropertyName(_jsMethodName(node.name.name)),
+    return new JS.Method(_jsMemberName(node.name.name),
         new JS.Fun(params, _visit(node.body)),
         isGetter: node.isGetter,
         isSetter: node.isSetter,
         isStatic: node.isStatic);
   }
 
   @override
   JS.Statement visitFunctionDeclaration(FunctionDeclaration node) {
     assert(node.parent is CompilationUnit);
 
@@ skipping 72 matching lines @@
     var e = node.staticElement;
     if (e == null) {
       return js.commentExpression(
           'Unimplemented unknown name', new JS.VariableUse(node.name));
     }
     var name = node.name;
     if (e.enclosingElement is CompilationUnitElement &&
         (e.library != libraryInfo.library || _needsModuleGetter(e))) {
       return js.call('#.#', [jsLibraryName(e.library), name]);
     } else if (currentClass != null && _needsImplicitThis(e)) {
-      return js.call('this.#', name);
+      return js.call('this.#', _jsMemberName(name));
+    } else if (e is ParameterElement && e.isInitializingFormal) {
+      name = _fieldParameterName(name);
     }
     return new JS.VariableUse(name);
   }
 
   JS.Expression _emitTypeName(DartType type) {
     var name = type.name;
     var lib = type.element.library;
     if (name == '') {
       // TODO(jmesserly): remove when we're using coercion reifier.
       return _unimplementedCall('Unimplemented type $type');
@@ skipping 186 matching lines @@
   }
 
   @override
   List<JS.Parameter> visitFormalParameterList(FormalParameterList node) {
     var result = <JS.Parameter>[];
     for (FormalParameter param in node.parameters) {
       if (param.kind == ParameterKind.NAMED) {
         result.add(new JS.Parameter(_jsNamedParameterName));
         break;
       }
-      result.add(new JS.Parameter(param.identifier.name));
+      result.add(_visit(param));
     }
     return result;
   }
 
   @override
   JS.Statement visitExpressionStatement(ExpressionStatement node) =>
       _expressionStatement(_visit(node.expression));
 
   // Some expressions may choose to generate themselves as JS statements
   // if their parent is in a statement context.
@@ skipping 343 matching lines @@
     }
     return false;
   }
 
   @override
   visitParenthesizedExpression(ParenthesizedExpression node) =>
       // The printer handles precedence so we don't need to.
       _visit(node.expression);
 
   @override
-  visitSimpleFormalParameter(SimpleFormalParameter node) =>
-      _visit(node.identifier);
+  visitFormalParameter(FormalParameter node) =>
+      new JS.Parameter(node.identifier.name);
 
   @override
-  visitFunctionTypedFormalParameter(FunctionTypedFormalParameter node) =>
-      _visit(node.identifier);
+  visitFieldFormalParameter(FieldFormalParameter node) =>
+      new JS.Parameter(_fieldParameterName(node.identifier.name));
+
+  /// Rename private names so they don't shadow the private field symbol.
+  // TODO(jmesserly): replace this ad-hoc rename with a general strategy.
+  _fieldParameterName(name) => name.startsWith('_') ? '\$$name' : name;
 
   @override
   JS.This visitThisExpression(ThisExpression node) => new JS.This();
 
   @override
   JS.Super visitSuperExpression(SuperExpression node) => new JS.Super();
 
   @override
   visitPrefixedIdentifier(PrefixedIdentifier node) {
     if (node.prefix.staticElement is PrefixElement) {
       return _visit(node.identifier);
     } else {
       return _visitGet(node.prefix, node.identifier);
     }
   }
 
   @override
   visitPropertyAccess(PropertyAccess node) =>
       _visitGet(_getTarget(node), node.propertyName);
 
   /// Shared code for [PrefixedIdentifier] and [PropertyAccess].
   _visitGet(Expression target, SimpleIdentifier name) {
     if (rules.isDynamicTarget(target)) {
       return js.call(
           'dart.dload(#, #)', [_visit(target), js.string(name.name, "'")]);
     } else {
-      return js.call('#.#', [_visit(target), name.name]);
+      return js.call('#.#', [_visit(target), _jsMemberName(name.name)]);
     }
   }
 
   @override
   visitIndexExpression(IndexExpression node) {
     var target = _getTarget(node);
     var code;
     if (rules.isDynamicTarget(target)) {
       code = 'dart.dindex(#, #)';
     } else {
@@ skipping 327 matching lines @@
       var jsExpr = _visit(node);
       if (result == null) {
         result = jsExpr;
       } else {
         result = new JS.Binary(operator, result, jsExpr);
       }
     }
     return result;
   }
 
-  /// The following names are allowed for user-defined operators:
+  /// This handles member renaming for private names and operators.
+  ///
+  /// Private names are generated using ES6 symbols:
+  ///
+  ///     // At the top of the module:
+  ///     let _x = Symbol('_x');
+  ///     let _y = Symbol('_y');
+  ///     ...
+  ///
+  ///     class Point {
+  ///       Point(x, y) {
+  ///         this[_x] = x;
+  ///         this[_y] = y;
+  ///       }
+  ///       get x() { return this[_x]; }
+  ///       get y() { return this[_y]; }
+  ///     }
+  ///
+  /// For user-defined operators the following names are allowed:
   ///
   ///     <, >, <=, >=, ==, -, +, /, ˜/, *, %, |, ˆ, &, <<, >>, []=, [], ˜
   ///
-  /// For the indexing operators, we use `get` and `set` instead:
+  /// They generate code like:
+  ///
+  ///     x['+'](y)
+  ///
+  /// There are three exceptions: [], []= and unary -.
+  /// The indexing operators we use `get` and `set` instead:
   ///
   ///     x.get('hi')
   ///     x.set('hi', 123)
   ///
   /// This follows the same pattern as EcmaScript 6 Map:
   /// <https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map>
   ///
-  /// For all others we use the operator name:
-  ///
-  ///     x['+'](y)
+  /// Unary minus looks like: `x['unary-']()`. Note that [unary] must be passed
+  /// for this transformation to happen, otherwise binary minus is assumed.
   ///
   /// Equality is a bit special, it is generated via the Dart `equals` runtime
   /// helper, that checks for null. The user defined method is called '=='.
-  String _jsMethodName(String name) {
-    if (name == '[]') return 'get';
-    if (name == '[]=') return 'set';
-    return name;
+  ///
+  JS.Expression _jsMemberName(String name, {bool unary: false}) {
+    if (name.startsWith('_')) {
+      _privateNames.add(name);
+      return new JS.VariableUse(name);
+    }
+    if (name == '[]') {
+      name = 'get';
+    } else if (name == '[]=') {
+      name = 'set';
+    } else if (unary && name == '-') {
+      name = 'unary-';
+    }
+    return new JS.PropertyName(name);
   }
 
   bool _externalOrNative(node) =>
       node.externalKeyword != null || _functionBody(node) is NativeFunctionBody;
 
   FunctionBody _functionBody(node) =>
       node is FunctionDeclaration ? node.functionExpression.body : node.body;
 
   String _maybeBindThis(node) {
     if (currentClass == null) return '';
@@ skipping 192 matching lines @@
 
     // TODO(jmesserly): in many cases marking the end will be unncessary.
     printer.mark(_location(node.end));
   }
 
   String _getIdentifier(AstNode node) {
     if (node is SimpleIdentifier) return node.name;
     return null;
   }
 }