pkg/compiler/lib/src/resolution/enum_creator.dart - sdk.git - Git at Google

 // Copyright (c) 2014, 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 dart2js.resolution.enum_creator;

 import '../common.dart';
 import '../common_elements.dart' show CommonElements;
 import '../elements/resolution_types.dart';
 import '../elements/elements.dart';
 import '../elements/modelx.dart';
 import 'package:front_end/src/fasta/scanner.dart';
 import 'package:front_end/src/scanner/token.dart' show KeywordToken, TokenType;
 import '../tree/tree.dart';
 import '../util/util.dart';

 // TODO(johnniwinther): Merge functionality with the `TreePrinter`.
 class AstBuilder {
   final int charOffset;

   AstBuilder(this.charOffset);

   Modifiers modifiers(
       {bool isConst: false, bool isFinal: false, bool isStatic: false}) {
     List identifiers = [];
     int flags = 0;
     if (isConst) {
       identifiers.add(identifier('const'));
       flags |= Modifiers.FLAG_CONST;
     }
     if (isFinal) {
       identifiers.add(identifier('final'));
       flags |= Modifiers.FLAG_FINAL;
     }
     if (isStatic) {
       identifiers.add(identifier('static'));
       flags |= Modifiers.FLAG_STATIC;
     }
     return new Modifiers.withFlags(
         new NodeList(null, linkedList(identifiers), null, ''), flags);
   }

   Token keywordToken(String text) {
     return new KeywordToken(Keyword.keywords[text], charOffset);
   }

   Token stringToken(String text) {
     return new StringToken.fromString(TokenType.IDENTIFIER, text, charOffset);
   }

   Token symbolToken(TokenType type) {
     return new Token(type, charOffset);
   }

   Identifier identifier(String text) {
     Keyword keyword = Keyword.keywords[text];
     Token token;
     if (keyword != null) {
       token = new KeywordToken(keyword, charOffset);
     } else {
       token = stringToken(text);
     }
     return new Identifier(token);
   }

   Link linkedList(List elements) {
     LinkBuilder builder = new LinkBuilder();
     elements.forEach((e) => builder.addLast(e));
     return builder.toLink();
   }

   NodeList argumentList(List<Node> nodes) {
     return new NodeList(symbolToken(TokenType.OPEN_PAREN), linkedList(nodes),
         symbolToken(TokenType.CLOSE_PAREN), ',');
   }

   Return returnStatement(Expression expression) {
     return new Return(
         keywordToken('return'), symbolToken(TokenType.SEMICOLON), expression);
   }

   FunctionExpression functionExpression(Modifiers modifiers, String name,
       NodeList typeVariables, NodeList argumentList, Statement body,
       [TypeAnnotation returnType]) {
     return new FunctionExpression(
         identifier(name),
         typeVariables,
         argumentList,
         body,
         returnType,
         modifiers,
         null, // Initializer.
         null, // get/set.
         null // Async modifier.
         );
   }

   EmptyStatement emptyStatement() {
     return new EmptyStatement(symbolToken(TokenType.COMMA));
   }

   LiteralInt literalInt(int value) {
     return new LiteralInt(stringToken('$value'), null);
   }

   LiteralString literalString(String text,
       {String prefix: '"', String suffix: '"'}) {
     return new LiteralString(
         stringToken('$prefix$text$suffix'), new DartString.literal(text));
   }

   LiteralList listLiteral(List<Node> elements, {bool isConst: false}) {
     return new LiteralList(
         null,
         new NodeList(
             symbolToken(TokenType.OPEN_SQUARE_BRACKET),
             linkedList(elements),
             symbolToken(TokenType.CLOSE_SQUARE_BRACKET),
             ','),
         isConst ? keywordToken('const') : null);
   }

   Node createDefinition(Identifier name, Expression initializer) {
     if (initializer == null) return name;
     return new SendSet(null, name, new Operator(symbolToken(TokenType.EQ)),
         new NodeList.singleton(initializer));
   }

   VariableDefinitions initializingFormal(String fieldName) {
     return new VariableDefinitions.forParameter(
         new NodeList.empty(),
         null,
         Modifiers.EMPTY,
         new NodeList.singleton(
             new Send(identifier('this'), identifier(fieldName))));
   }

   NewExpression newExpression(String typeName, NodeList arguments,
       {bool isConst: false}) {
     return new NewExpression(keywordToken(isConst ? 'const' : 'new'),
         new Send(null, identifier(typeName), arguments));
   }

   Send reference(Identifier identifier) {
     return new Send(null, identifier);
   }

   Send indexGet(Expression receiver, Expression index) {
     return new Send(receiver, new Operator(symbolToken(TokenType.INDEX)),
         new NodeList.singleton(index));
   }

   LiteralMapEntry mapLiteralEntry(Expression key, Expression value) {
     return new LiteralMapEntry(key, symbolToken(TokenType.COLON), value);
   }

   LiteralMap mapLiteral(List<LiteralMapEntry> entries, {bool isConst: false}) {
     return new LiteralMap(
         null, // Type arguments.
         new NodeList(
             symbolToken(TokenType.OPEN_CURLY_BRACKET),
             linkedList(entries),
             symbolToken(TokenType.CLOSE_CURLY_BRACKET),
             ','),
         isConst ? keywordToken('const') : null);
   }
 }

 /// This class generates the model for an enum class.
 ///
 /// For instance
 ///
 ///     enum A { b, c, }
 ///
 /// is modelled as
 ///
 ///     class A {
 ///       final int index;
 ///       final String _name;
 ///
 ///       const A(this.index);
 ///
 ///       String toString() {
 ///         return _name;
 ///       }
 ///
 ///       static const A b = const A(0, "A.b");
 ///       static const A c = const A(1, "A.v");
 ///
 ///       static const List<A> values = const <A>[b, c];
 ///     }
 ///
 // TODO(johnniwinther): Avoid creating synthesized ASTs for enums when SSA is
 // removed.
 class EnumCreator {
   final DiagnosticReporter reporter;
   final CommonElements commonElements;
   final EnumClassElementX enumClass;

   EnumCreator(this.reporter, this.commonElements, this.enumClass);

   /// Whether to use a constant-map to encode the result of toString on an enum
   /// value.
   ///
   /// Dart2js by default uses a compact representation of enum values that
   /// include their name. The spec and the kernel-based implementation use a
   /// const-map to encode the result of toString. This flag is used to disable
   /// the default representation, and instead match the kernel representation to
   /// make it easier to test the equivalence of resolution-based and
   /// kernel-based world builders.
   static bool matchKernelRepresentationForTesting = false;

   void createMembers() {
     Enum node = enumClass.node;
     ResolutionInterfaceType enumType = enumClass.thisType;
     AstBuilder builder = new AstBuilder(enumClass.position.charOffset);

     ResolutionInterfaceType intType = commonElements.intType;
     ResolutionInterfaceType stringType = commonElements.stringType;

     EnumFieldElementX addInstanceMember(
         String name, ResolutionInterfaceType type) {
       Identifier identifier = builder.identifier(name);
       VariableList variableList =
           new VariableList(builder.modifiers(isFinal: true));
       variableList.type = type;
       EnumFieldElementX variable = new EnumFieldElementX(
           identifier, enumClass, variableList, identifier);
       enumClass.addMember(variable, reporter);
       return variable;
     }

     EnumFieldElementX indexVariable = addInstanceMember('index', intType);
     EnumFieldElementX nameVariable;

     VariableDefinitions indexDefinition = builder.initializingFormal('index');
     VariableDefinitions nameDefinition;

     List<Node> constructorInitializers = <Node>[indexDefinition];
     if (!matchKernelRepresentationForTesting) {
       nameVariable = addInstanceMember('_name', stringType);
       nameDefinition = builder.initializingFormal('_name');
       constructorInitializers.add(nameDefinition);
     }
     FunctionExpression constructorNode = builder.functionExpression(
         builder.modifiers(isConst: true),
         enumClass.name,
         null, // typeVariables
         builder.argumentList(constructorInitializers),
         builder.emptyStatement());

     EnumConstructorElementX constructor = new EnumConstructorElementX(
         enumClass, builder.modifiers(isConst: true), constructorNode);

     EnumFormalElementX indexFormal = new EnumFormalElementX(constructor,
         indexDefinition, builder.identifier('index'), indexVariable);

     EnumFormalElementX nameFormal;

     List<FormalElement> parameters = <FormalElement>[indexFormal];
     List<ResolutionDartType> parameterTypes = <ResolutionDartType>[intType];
     if (!matchKernelRepresentationForTesting) {
       nameFormal = new EnumFormalElementX(constructor, nameDefinition,
           builder.identifier('_name'), nameVariable);
       parameters.add(nameFormal);
       parameterTypes.add(stringType);
     }
     FunctionSignatureX constructorSignature = new FunctionSignatureX(
         requiredParameters: parameters,
         requiredParameterCount: parameters.length,
         type: new ResolutionFunctionType(
             constructor, const ResolutionDynamicType(), parameterTypes));
     constructor.functionSignature = constructorSignature;
     enumClass.addMember(constructor, reporter);

     List<EnumConstantElement> enumValues = <EnumConstantElement>[];
     int index = 0;
     List<Node> valueReferences = <Node>[];
     List<LiteralMapEntry> mapEntries;
     if (matchKernelRepresentationForTesting) {
       mapEntries = <LiteralMapEntry>[];
     }
     for (Link<Node> link = node.names.nodes; !link.isEmpty; link = link.tail) {
       Identifier name = link.head;
       AstBuilder valueBuilder = new AstBuilder(name.token.charOffset);
       VariableList variableList = new VariableList(
           valueBuilder.modifiers(isStatic: true, isConst: true));
       variableList.type = enumType;

       // Add reference for the `values` field.
       valueReferences.add(valueBuilder.reference(name));

       Node indexValue = valueBuilder.literalInt(index);
       Node nameValue =
           valueBuilder.literalString('${enumClass.name}.${name.source}');
       Expression initializer;
       if (matchKernelRepresentationForTesting) {
         // Add map entry for `toString` implementation.
         mapEntries.add(valueBuilder.mapLiteralEntry(indexValue, nameValue));

         initializer = valueBuilder.newExpression(
             enumClass.name, valueBuilder.argumentList([indexValue]),
             isConst: true);
       } else {
         initializer = valueBuilder.newExpression(
             enumClass.name, valueBuilder.argumentList([indexValue, nameValue]),
             isConst: true);
       }
       SendSet definition = valueBuilder.createDefinition(name, initializer);

       EnumConstantElementX field = new EnumConstantElementX(
           name, enumClass, variableList, definition, initializer, index);
       enumValues.add(field);
       enumClass.addMember(field, reporter);
       index++;
     }

     VariableList valuesVariableList =
         new VariableList(builder.modifiers(isStatic: true, isConst: true));
     ResolutionInterfaceType valuesType = commonElements.listType(enumType);
     valuesVariableList.type = valuesType;

     Identifier valuesIdentifier = builder.identifier('values');
     // TODO(28340): Add type argument.
     Expression initializer =
         builder.listLiteral(valueReferences, isConst: true);

     Node definition = builder.createDefinition(valuesIdentifier, initializer);

     EnumFieldElementX valuesVariable = new EnumFieldElementX(valuesIdentifier,
         enumClass, valuesVariableList, definition, initializer);

     enumClass.addMember(valuesVariable, reporter);

     Node toStringValue;
     if (matchKernelRepresentationForTesting) {
       toStringValue = builder.indexGet(
           builder.mapLiteral(mapEntries, isConst: true),
           builder.reference(builder.identifier('index')));
     } else {
       toStringValue = builder.reference(builder.identifier('_name'));
     }
     FunctionExpression toStringNode = builder.functionExpression(
         Modifiers.EMPTY,
         'toString',
         null, // typeVariables
         builder.argumentList([]),
         builder.returnStatement(toStringValue));

     EnumMethodElementX toString = new EnumMethodElementX(
         'toString', enumClass, Modifiers.EMPTY, toStringNode);
     FunctionSignatureX toStringSignature = new FunctionSignatureX(
         type: new ResolutionFunctionType(toString, stringType));
     toString.functionSignature = toStringSignature;
     enumClass.addMember(toString, reporter);

     enumClass.enumValues = enumValues;
   }
 }
	// Copyright (c) 2014, 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 dart2js.resolution.enum_creator;

	import '../common.dart';
	import '../common_elements.dart' show CommonElements;
	import '../elements/resolution_types.dart';
	import '../elements/elements.dart';
	import '../elements/modelx.dart';
	import 'package:front_end/src/fasta/scanner.dart';
	import 'package:front_end/src/scanner/token.dart' show KeywordToken, TokenType;
	import '../tree/tree.dart';
	import '../util/util.dart';

	// TODO(johnniwinther): Merge functionality with the `TreePrinter`.
	class AstBuilder {
	final int charOffset;

	AstBuilder(this.charOffset);

	Modifiers modifiers(
	{bool isConst: false, bool isFinal: false, bool isStatic: false}) {
	List identifiers = [];
	int flags = 0;
	if (isConst) {
	identifiers.add(identifier('const'));
	flags \|= Modifiers.FLAG_CONST;
	}
	if (isFinal) {
	identifiers.add(identifier('final'));
	flags \|= Modifiers.FLAG_FINAL;
	}
	if (isStatic) {
	identifiers.add(identifier('static'));
	flags \|= Modifiers.FLAG_STATIC;
	}
	return new Modifiers.withFlags(
	new NodeList(null, linkedList(identifiers), null, ''), flags);
	}

	Token keywordToken(String text) {
	return new KeywordToken(Keyword.keywords[text], charOffset);
	}

	Token stringToken(String text) {
	return new StringToken.fromString(TokenType.IDENTIFIER, text, charOffset);
	}

	Token symbolToken(TokenType type) {
	return new Token(type, charOffset);
	}

	Identifier identifier(String text) {
	Keyword keyword = Keyword.keywords[text];
	Token token;
	if (keyword != null) {
	token = new KeywordToken(keyword, charOffset);
	} else {
	token = stringToken(text);
	}
	return new Identifier(token);
	}

	Link linkedList(List elements) {
	LinkBuilder builder = new LinkBuilder();
	elements.forEach((e) => builder.addLast(e));
	return builder.toLink();
	}

	NodeList argumentList(List<Node> nodes) {
	return new NodeList(symbolToken(TokenType.OPEN_PAREN), linkedList(nodes),
	symbolToken(TokenType.CLOSE_PAREN), ',');
	}

	Return returnStatement(Expression expression) {
	return new Return(
	keywordToken('return'), symbolToken(TokenType.SEMICOLON), expression);
	}

	FunctionExpression functionExpression(Modifiers modifiers, String name,
	NodeList typeVariables, NodeList argumentList, Statement body,
	[TypeAnnotation returnType]) {
	return new FunctionExpression(
	identifier(name),
	typeVariables,
	argumentList,
	body,
	returnType,
	modifiers,
	null, // Initializer.
	null, // get/set.
	null // Async modifier.
	);
	}

	EmptyStatement emptyStatement() {
	return new EmptyStatement(symbolToken(TokenType.COMMA));
	}

	LiteralInt literalInt(int value) {
	return new LiteralInt(stringToken('$value'), null);
	}

	LiteralString literalString(String text,
	{String prefix: '"', String suffix: '"'}) {
	return new LiteralString(
	stringToken('$prefix$text$suffix'), new DartString.literal(text));
	}

	LiteralList listLiteral(List<Node> elements, {bool isConst: false}) {
	return new LiteralList(
	null,
	new NodeList(
	symbolToken(TokenType.OPEN_SQUARE_BRACKET),
	linkedList(elements),
	symbolToken(TokenType.CLOSE_SQUARE_BRACKET),
	','),
	isConst ? keywordToken('const') : null);
	}

	Node createDefinition(Identifier name, Expression initializer) {
	if (initializer == null) return name;
	return new SendSet(null, name, new Operator(symbolToken(TokenType.EQ)),
	new NodeList.singleton(initializer));
	}

	VariableDefinitions initializingFormal(String fieldName) {
	return new VariableDefinitions.forParameter(
	new NodeList.empty(),
	null,
	Modifiers.EMPTY,
	new NodeList.singleton(
	new Send(identifier('this'), identifier(fieldName))));
	}

	NewExpression newExpression(String typeName, NodeList arguments,
	{bool isConst: false}) {
	return new NewExpression(keywordToken(isConst ? 'const' : 'new'),
	new Send(null, identifier(typeName), arguments));
	}

	Send reference(Identifier identifier) {
	return new Send(null, identifier);
	}

	Send indexGet(Expression receiver, Expression index) {
	return new Send(receiver, new Operator(symbolToken(TokenType.INDEX)),
	new NodeList.singleton(index));
	}

	LiteralMapEntry mapLiteralEntry(Expression key, Expression value) {
	return new LiteralMapEntry(key, symbolToken(TokenType.COLON), value);
	}

	LiteralMap mapLiteral(List<LiteralMapEntry> entries, {bool isConst: false}) {
	return new LiteralMap(
	null, // Type arguments.
	new NodeList(
	symbolToken(TokenType.OPEN_CURLY_BRACKET),
	linkedList(entries),
	symbolToken(TokenType.CLOSE_CURLY_BRACKET),
	','),
	isConst ? keywordToken('const') : null);
	}
	}

	/// This class generates the model for an enum class.
	///
	/// For instance
	///
	/// enum A { b, c, }
	///
	/// is modelled as
	///
	/// class A {
	/// final int index;
	/// final String _name;
	///
	/// const A(this.index);
	///
	/// String toString() {
	/// return _name;
	/// }
	///
	/// static const A b = const A(0, "A.b");
	/// static const A c = const A(1, "A.v");
	///
	/// static const List<A> values = const <A>[b, c];
	/// }
	///
	// TODO(johnniwinther): Avoid creating synthesized ASTs for enums when SSA is
	// removed.
	class EnumCreator {
	final DiagnosticReporter reporter;
	final CommonElements commonElements;
	final EnumClassElementX enumClass;

	EnumCreator(this.reporter, this.commonElements, this.enumClass);

	/// Whether to use a constant-map to encode the result of toString on an enum
	/// value.
	///
	/// Dart2js by default uses a compact representation of enum values that
	/// include their name. The spec and the kernel-based implementation use a
	/// const-map to encode the result of toString. This flag is used to disable
	/// the default representation, and instead match the kernel representation to
	/// make it easier to test the equivalence of resolution-based and
	/// kernel-based world builders.
	static bool matchKernelRepresentationForTesting = false;

	void createMembers() {
	Enum node = enumClass.node;
	ResolutionInterfaceType enumType = enumClass.thisType;
	AstBuilder builder = new AstBuilder(enumClass.position.charOffset);

	ResolutionInterfaceType intType = commonElements.intType;
	ResolutionInterfaceType stringType = commonElements.stringType;

	EnumFieldElementX addInstanceMember(
	String name, ResolutionInterfaceType type) {
	Identifier identifier = builder.identifier(name);
	VariableList variableList =
	new VariableList(builder.modifiers(isFinal: true));
	variableList.type = type;
	EnumFieldElementX variable = new EnumFieldElementX(
	identifier, enumClass, variableList, identifier);
	enumClass.addMember(variable, reporter);
	return variable;
	}

	EnumFieldElementX indexVariable = addInstanceMember('index', intType);
	EnumFieldElementX nameVariable;

	VariableDefinitions indexDefinition = builder.initializingFormal('index');
	VariableDefinitions nameDefinition;

	List<Node> constructorInitializers = <Node>[indexDefinition];
	if (!matchKernelRepresentationForTesting) {
	nameVariable = addInstanceMember('_name', stringType);
	nameDefinition = builder.initializingFormal('_name');
	constructorInitializers.add(nameDefinition);
	}
	FunctionExpression constructorNode = builder.functionExpression(
	builder.modifiers(isConst: true),
	enumClass.name,
	null, // typeVariables
	builder.argumentList(constructorInitializers),
	builder.emptyStatement());

	EnumConstructorElementX constructor = new EnumConstructorElementX(
	enumClass, builder.modifiers(isConst: true), constructorNode);

	EnumFormalElementX indexFormal = new EnumFormalElementX(constructor,
	indexDefinition, builder.identifier('index'), indexVariable);

	EnumFormalElementX nameFormal;

	List<FormalElement> parameters = <FormalElement>[indexFormal];
	List<ResolutionDartType> parameterTypes = <ResolutionDartType>[intType];
	if (!matchKernelRepresentationForTesting) {
	nameFormal = new EnumFormalElementX(constructor, nameDefinition,
	builder.identifier('_name'), nameVariable);
	parameters.add(nameFormal);
	parameterTypes.add(stringType);
	}
	FunctionSignatureX constructorSignature = new FunctionSignatureX(
	requiredParameters: parameters,
	requiredParameterCount: parameters.length,
	type: new ResolutionFunctionType(
	constructor, const ResolutionDynamicType(), parameterTypes));
	constructor.functionSignature = constructorSignature;
	enumClass.addMember(constructor, reporter);

	List<EnumConstantElement> enumValues = <EnumConstantElement>[];
	int index = 0;
	List<Node> valueReferences = <Node>[];
	List<LiteralMapEntry> mapEntries;
	if (matchKernelRepresentationForTesting) {
	mapEntries = <LiteralMapEntry>[];
	}
	for (Link<Node> link = node.names.nodes; !link.isEmpty; link = link.tail) {
	Identifier name = link.head;
	AstBuilder valueBuilder = new AstBuilder(name.token.charOffset);
	VariableList variableList = new VariableList(
	valueBuilder.modifiers(isStatic: true, isConst: true));
	variableList.type = enumType;

	// Add reference for the `values` field.
	valueReferences.add(valueBuilder.reference(name));

	Node indexValue = valueBuilder.literalInt(index);
	Node nameValue =
	valueBuilder.literalString('${enumClass.name}.${name.source}');
	Expression initializer;
	if (matchKernelRepresentationForTesting) {
	// Add map entry for `toString` implementation.
	mapEntries.add(valueBuilder.mapLiteralEntry(indexValue, nameValue));

	initializer = valueBuilder.newExpression(
	enumClass.name, valueBuilder.argumentList([indexValue]),
	isConst: true);
	} else {
	initializer = valueBuilder.newExpression(
	enumClass.name, valueBuilder.argumentList([indexValue, nameValue]),
	isConst: true);
	}
	SendSet definition = valueBuilder.createDefinition(name, initializer);

	EnumConstantElementX field = new EnumConstantElementX(
	name, enumClass, variableList, definition, initializer, index);
	enumValues.add(field);
	enumClass.addMember(field, reporter);
	index++;
	}

	VariableList valuesVariableList =
	new VariableList(builder.modifiers(isStatic: true, isConst: true));
	ResolutionInterfaceType valuesType = commonElements.listType(enumType);
	valuesVariableList.type = valuesType;

	Identifier valuesIdentifier = builder.identifier('values');
	// TODO(28340): Add type argument.
	Expression initializer =
	builder.listLiteral(valueReferences, isConst: true);

	Node definition = builder.createDefinition(valuesIdentifier, initializer);

	EnumFieldElementX valuesVariable = new EnumFieldElementX(valuesIdentifier,
	enumClass, valuesVariableList, definition, initializer);

	enumClass.addMember(valuesVariable, reporter);

	Node toStringValue;
	if (matchKernelRepresentationForTesting) {
	toStringValue = builder.indexGet(
	builder.mapLiteral(mapEntries, isConst: true),
	builder.reference(builder.identifier('index')));
	} else {
	toStringValue = builder.reference(builder.identifier('_name'));
	}
	FunctionExpression toStringNode = builder.functionExpression(
	Modifiers.EMPTY,
	'toString',
	null, // typeVariables
	builder.argumentList([]),
	builder.returnStatement(toStringValue));

	EnumMethodElementX toString = new EnumMethodElementX(
	'toString', enumClass, Modifiers.EMPTY, toStringNode);
	FunctionSignatureX toStringSignature = new FunctionSignatureX(
	type: new ResolutionFunctionType(toString, stringType));
	toString.functionSignature = toStringSignature;
	enumClass.addMember(toString, reporter);

	enumClass.enumValues = enumValues;
	}
	}