blob: 85d6a9a6dcbc9fd6623f520ec57e9ce001bb3d91 [file] [log] [blame]
// 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.
/**
* Code generation for the file "AnalysisServer.java".
*/
import 'package:analyzer/src/codegen/tools.dart';
import 'package:front_end/src/codegen/tools.dart';
import 'package:html/dom.dart' as dom;
import 'api.dart';
import 'codegen_java.dart';
import 'from_html.dart';
import 'implied_types.dart';
/**
* A map between the field names and values for the Element object such as:
*
* private static final int ABSTRACT = 0x01;
*/
const Map<String, String> _extraFieldsOnElement = const {
'ABSTRACT': '0x01',
'CONST': '0x02',
'FINAL': '0x04',
'TOP_LEVEL_STATIC': '0x08',
'PRIVATE': '0x10',
'DEPRECATED': '0x20',
};
/**
* A map between the method names and field names to generate additional methods on the Element object:
*
* public boolean isFinal() {
* return (flags & FINAL) != 0;
* }
*/
const Map<String, String> _extraMethodsOnElement = const {
'isAbstract': 'ABSTRACT',
'isConst': 'CONST',
'isDeprecated': 'DEPRECATED',
'isFinal': 'FINAL',
'isPrivate': 'PRIVATE',
'isTopLevelOrStatic': 'TOP_LEVEL_STATIC',
};
/**
* Type references in the spec that are named something else in Java.
*/
const Map<String, String> _typeRenames = const {
'Override': 'OverrideMember',
};
final String pathToGenTypes = 'tool/spec/generated/java/types';
final GeneratedDirectory targetDir =
new GeneratedDirectory(pathToGenTypes, (String pkgPath) {
Api api = readApi(pkgPath);
Map<String, ImpliedType> impliedTypes = computeImpliedTypes(api);
Map<String, FileContentsComputer> map =
new Map<String, FileContentsComputer>();
for (ImpliedType impliedType in impliedTypes.values) {
String typeNameInSpec = capitalize(impliedType.camelName);
bool isRefactoringFeedback = impliedType.kind == 'refactoringFeedback';
bool isRefactoringOption = impliedType.kind == 'refactoringOptions';
if (impliedType.kind == 'typeDefinition' ||
isRefactoringFeedback ||
isRefactoringOption) {
TypeDecl type = impliedType.type;
if (type is TypeObject || type is TypeEnum) {
// This is for situations such as 'Override' where the name in the spec
// doesn't match the java object that we generate:
String typeNameInJava = typeNameInSpec;
if (_typeRenames.containsKey(typeNameInSpec)) {
typeNameInJava = _typeRenames[typeNameInSpec];
}
map['$typeNameInJava.java'] = (String pkgPath) async {
String superclassName = null;
if (isRefactoringFeedback) {
superclassName = 'RefactoringFeedback';
}
if (isRefactoringOption) {
superclassName = 'RefactoringOptions';
}
// configure accessors
bool generateGetters = true;
bool generateSetters = false;
if (isRefactoringOption ||
typeNameInSpec == 'Outline' ||
typeNameInSpec == 'RefactoringMethodParameter') {
generateSetters = true;
}
// create the visitor
CodegenJavaType visitor = new CodegenJavaType(api, typeNameInJava,
superclassName, generateGetters, generateSetters);
return visitor.collectCode(() {
dom.Element doc = type.html;
if (impliedType.apiNode is TypeDefinition) {
doc = (impliedType.apiNode as TypeDefinition).html;
}
visitor.emitType(type, doc);
});
};
}
}
}
return map;
});
class CodegenJavaType extends CodegenJavaVisitor {
final String className;
final String superclassName;
final bool generateGetters;
final bool generateSetters;
CodegenJavaType(Api api, this.className, this.superclassName,
this.generateGetters, this.generateSetters)
: super(api);
/**
* Get the name of the consumer class for responses to this request.
*/
String consumerName(Request request) {
return camelJoin([request.method, 'consumer'], doCapitalize: true);
}
void emitType(TypeDecl type, dom.Element html) {
outputHeader(javaStyle: true);
writeln('package org.dartlang.analysis.server.protocol;');
writeln();
if (type is TypeObject) {
_writeTypeObject(type, html);
} else if (type is TypeEnum) {
_writeTypeEnum(type, html);
}
}
String _getAsTypeMethodName(TypeDecl typeDecl) {
String name = javaType(typeDecl, true);
if (name == 'String') {
return 'getAsString';
} else if (name == 'boolean' || name == 'Boolean') {
return 'getAsBoolean';
} else if (name == 'int' || name == 'Integer') {
return 'getAsInt';
} else if (name == 'long' || name == 'Long') {
return 'getAsLong';
} else if (name.startsWith('List')) {
return 'getAsJsonArray';
} else {
// TODO (jwren) cleanup
return 'getAsJsonArray';
}
}
String _getEqualsLogicForField(TypeObjectField field, String other) {
String name = javaName(field.name);
if (isPrimitive(field.type) && !field.optional) {
return '$other.$name == $name';
} else if (isArray(field.type)) {
return 'Arrays.equals(other.$name, $name)';
} else {
return 'ObjectUtilities.equals($other.$name, $name)';
}
}
/**
* For some [TypeObjectField] return the [String] source for the field value
* for the toString generation.
*/
String _getToStringForField(TypeObjectField field) {
String name = javaName(field.name);
if (isArray(field.type) || isList(field.type)) {
return 'StringUtils.join($name, ", ")';
} else {
return name;
}
}
bool _isTypeFieldInUpdateContentUnionType(
String className, String fieldName) {
if ((className == 'AddContentOverlay' ||
className == 'ChangeContentOverlay' ||
className == 'RemoveContentOverlay') &&
fieldName == 'type') {
return true;
} else {
return false;
}
}
/**
* This method writes extra fields and methods to the Element type.
*/
void _writeExtraContentInElementType() {
//
// Extra fields on the Element type such as:
// private static final int ABSTRACT = 0x01;
//
_extraFieldsOnElement.forEach((String name, String value) {
publicField(javaName(name), () {
writeln('private static final int $name = $value;');
});
});
//
// Extra methods for the Element type such as:
// public boolean isFinal() {
// return (flags & FINAL) != 0;
// }
//
_extraMethodsOnElement.forEach((String methodName, String fieldName) {
publicMethod(methodName, () {
writeln('public boolean $methodName() {');
writeln(' return (flags & $fieldName) != 0;');
writeln('}');
});
});
}
/**
* For some [TypeObjectField] write out the source that adds the field
* information to the 'jsonObject'.
*/
void _writeOutJsonObjectAddStatement(TypeObjectField field) {
String name = javaName(field.name);
if (isDeclaredInSpec(field.type)) {
writeln('jsonObject.add("$name", $name.toJson());');
} else if (field.type is TypeList) {
TypeDecl listItemType = (field.type as TypeList).itemType;
String jsonArrayName = 'jsonArray${capitalize(name)}';
writeln('JsonArray $jsonArrayName = new JsonArray();');
writeln('for (${javaType(listItemType)} elt : $name) {');
indent(() {
if (isDeclaredInSpec(listItemType)) {
writeln('$jsonArrayName.add(elt.toJson());');
} else {
writeln('$jsonArrayName.add(new JsonPrimitive(elt));');
}
});
writeln('}');
writeln('jsonObject.add("$name", $jsonArrayName);');
} else {
writeln('jsonObject.addProperty("$name", $name);');
}
}
void _writeTypeEnum(TypeDecl type, dom.Element html) {
javadocComment(toHtmlVisitor.collectHtml(() {
toHtmlVisitor.translateHtml(html);
toHtmlVisitor.br();
toHtmlVisitor.write('@coverage dart.server.generated.types');
}));
makeClass('public class $className', () {
TypeEnum typeEnum = type as TypeEnum;
List<TypeEnumValue> values = typeEnum.values;
//
// enum fields
//
for (TypeEnumValue value in values) {
privateField(javaName(value.value), () {
javadocComment(toHtmlVisitor.collectHtml(() {
toHtmlVisitor.translateHtml(value.html);
}));
writeln(
'public static final String ${value.value} = \"${value.value}\";');
});
}
});
}
void _writeTypeObject(TypeDecl type, dom.Element html) {
writeln('import java.util.Arrays;');
writeln('import java.util.List;');
writeln('import java.util.Map;');
writeln('import com.google.common.collect.Lists;');
writeln('import com.google.dart.server.utilities.general.JsonUtilities;');
writeln('import com.google.dart.server.utilities.general.ObjectUtilities;');
writeln('import com.google.gson.JsonArray;');
writeln('import com.google.gson.JsonElement;');
writeln('import com.google.gson.JsonObject;');
writeln('import com.google.gson.JsonPrimitive;');
writeln('import org.apache.commons.lang3.builder.HashCodeBuilder;');
writeln('import java.util.ArrayList;');
writeln('import java.util.Iterator;');
writeln('import org.apache.commons.lang3.StringUtils;');
writeln();
javadocComment(toHtmlVisitor.collectHtml(() {
toHtmlVisitor.translateHtml(html);
toHtmlVisitor.br();
toHtmlVisitor.write('@coverage dart.server.generated.types');
}));
writeln('@SuppressWarnings("unused")');
String header = 'public class $className';
if (superclassName != null) {
header += ' extends $superclassName';
}
makeClass(header, () {
//
// fields
//
//
// public static final "EMPTY_ARRAY" field
//
publicField(javaName("EMPTY_ARRAY"), () {
writeln(
'public static final $className[] EMPTY_ARRAY = new $className[0];');
});
//
// public static final "EMPTY_LIST" field
//
publicField(javaName("EMPTY_LIST"), () {
writeln(
'public static final List<$className> EMPTY_LIST = Lists.newArrayList();');
});
//
// "private static String name;" fields:
//
TypeObject typeObject = type as TypeObject;
List<TypeObjectField> fields = typeObject.fields;
for (TypeObjectField field in fields) {
String type = javaFieldType(field);
String name = javaName(field.name);
if (!(className == 'Outline' && name == 'children')) {
privateField(name, () {
javadocComment(toHtmlVisitor.collectHtml(() {
toHtmlVisitor.translateHtml(field.html);
}));
if (generateSetters) {
writeln('private $type $name;');
} else {
writeln('private final $type $name;');
}
});
}
}
if (className == 'Outline') {
privateField(javaName('parent'), () {
writeln('private final Outline parent;');
});
privateField(javaName('children'), () {
writeln('private List<Outline> children;');
});
}
if (className == 'NavigationRegion') {
privateField(javaName('targetObjects'), () {
writeln(
'private final List<NavigationTarget> targetObjects = Lists.newArrayList();');
});
}
if (className == 'NavigationTarget') {
privateField(javaName('file'), () {
writeln('private String file;');
});
}
//
// constructor
//
constructor(className, () {
javadocComment(toHtmlVisitor.collectHtml(() {
toHtmlVisitor.write('Constructor for {@link $className}.');
}));
write('public $className(');
// write out parameters to constructor
List<String> parameters = new List();
if (className == 'Outline') {
parameters.add('Outline parent');
}
for (TypeObjectField field in fields) {
String type = javaFieldType(field);
String name = javaName(field.name);
if (!_isTypeFieldInUpdateContentUnionType(className, field.name) &&
!(className == 'Outline' && name == 'children')) {
parameters.add('$type $name');
}
}
write(parameters.join(', '));
writeln(') {');
// write out the assignments in the body of the constructor
indent(() {
if (className == 'Outline') {
writeln('this.parent = parent;');
}
for (TypeObjectField field in fields) {
String name = javaName(field.name);
if (!_isTypeFieldInUpdateContentUnionType(className, field.name) &&
!(className == 'Outline' && name == 'children')) {
writeln('this.$name = $name;');
} else if (className == 'AddContentOverlay') {
writeln('this.type = "add";');
} else if (className == 'ChangeContentOverlay') {
writeln('this.type = "change";');
} else if (className == 'RemoveContentOverlay') {
writeln('this.type = "remove";');
}
}
});
writeln('}');
});
//
// getter methods
//
if (generateGetters) {
for (TypeObjectField field in fields) {
String type = javaFieldType(field);
String name = javaName(field.name);
publicMethod('get$name', () {
javadocComment(toHtmlVisitor.collectHtml(() {
toHtmlVisitor.translateHtml(field.html);
}));
if (type == 'boolean') {
writeln('public $type $name() {');
} else {
writeln('public $type get${capitalize(name)}() {');
}
writeln(' return $name;');
writeln('}');
});
}
}
//
// setter methods
//
if (generateSetters) {
for (TypeObjectField field in fields) {
String type = javaFieldType(field);
String name = javaName(field.name);
publicMethod('set$name', () {
javadocComment(toHtmlVisitor.collectHtml(() {
toHtmlVisitor.translateHtml(field.html);
}));
String setterName = 'set' + capitalize(name);
writeln('public void $setterName($type $name) {');
writeln(' this.$name = $name;');
writeln('}');
});
}
}
if (className == 'NavigationRegion') {
publicMethod('lookupTargets', () {
writeln(
'public void lookupTargets(List<NavigationTarget> allTargets) {');
writeln(' for (int i = 0; i < targets.length; i++) {');
writeln(' int targetIndex = targets[i];');
writeln(' NavigationTarget target = allTargets.get(targetIndex);');
writeln(' targetObjects.add(target);');
writeln(' }');
writeln('}');
});
publicMethod('getTargetObjects', () {
writeln('public List<NavigationTarget> getTargetObjects() {');
writeln(' return targetObjects;');
writeln('}');
});
}
if (className == 'NavigationTarget') {
publicMethod('lookupFile', () {
writeln('public void lookupFile(String[] allTargetFiles) {');
writeln(' file = allTargetFiles[fileIndex];');
writeln('}');
});
publicMethod('getFile', () {
writeln('public String getFile() {');
writeln(' return file;');
writeln('}');
});
}
//
// fromJson(JsonObject) factory constructor, example:
// public JsonObject toJson(JsonObject jsonObject) {
// String x = jsonObject.get("x").getAsString();
// return new Y(x);
// }
if (className != 'Outline') {
publicMethod('fromJson', () {
writeln('public static $className fromJson(JsonObject jsonObject) {');
indent(() {
for (TypeObjectField field in fields) {
write('${javaFieldType(field)} ${javaName(field.name)} = ');
if (field.optional) {
write(
'jsonObject.get("${javaName(field.name)}") == null ? null : ');
}
if (isDeclaredInSpec(field.type)) {
write('${javaFieldType(field)}.fromJson(');
write(
'jsonObject.get("${javaName(field.name)}").getAsJsonObject())');
} else {
if (isList(field.type)) {
if (javaFieldType(field).endsWith('<String>')) {
write(
'JsonUtilities.decodeStringList(jsonObject.get("${javaName(field.name)}").${_getAsTypeMethodName(field.type)}())');
} else {
write(
'${javaType((field.type as TypeList).itemType)}.fromJsonArray(jsonObject.get("${javaName(field.name)}").${_getAsTypeMethodName(field.type)}())');
}
} else if (isArray(field.type)) {
if (javaFieldType(field).startsWith('int')) {
write(
'JsonUtilities.decodeIntArray(jsonObject.get("${javaName(field.name)}").${_getAsTypeMethodName(field.type)}())');
}
} else {
write(
'jsonObject.get("${javaName(field.name)}").${_getAsTypeMethodName(field.type)}()');
}
}
writeln(';');
}
write('return new $className(');
List<String> parameters = new List();
for (TypeObjectField field in fields) {
if (!_isTypeFieldInUpdateContentUnionType(
className, field.name)) {
parameters.add('${javaName(field.name)}');
}
}
write(parameters.join(', '));
writeln(');');
});
writeln('}');
});
} else {
publicMethod('fromJson', () {
writeln(
'''public static Outline fromJson(Outline parent, JsonObject outlineObject) {
JsonObject elementObject = outlineObject.get("element").getAsJsonObject();
Element element = Element.fromJson(elementObject);
int offset = outlineObject.get("offset").getAsInt();
int length = outlineObject.get("length").getAsInt();
// create outline object
Outline outline = new Outline(parent, element, offset, length);
// compute children recursively
List<Outline> childrenList = Lists.newArrayList();
JsonElement childrenJsonArray = outlineObject.get("children");
if (childrenJsonArray instanceof JsonArray) {
Iterator<JsonElement> childrenElementIterator = ((JsonArray) childrenJsonArray).iterator();
while (childrenElementIterator.hasNext()) {
JsonObject childObject = childrenElementIterator.next().getAsJsonObject();
childrenList.add(fromJson(outline, childObject));
}
}
outline.setChildren(childrenList);
return outline;
}''');
});
publicMethod('getParent', () {
writeln('''public Outline getParent() {
return parent;
}''');
});
}
//
// fromJson(JsonArray) factory constructor
//
if (className != 'Outline' &&
className != 'RefactoringFeedback' &&
className != 'RefactoringOptions') {
publicMethod('fromJsonArray', () {
writeln(
'public static List<$className> fromJsonArray(JsonArray jsonArray) {');
indent(() {
writeln('if (jsonArray == null) {');
writeln(' return EMPTY_LIST;');
writeln('}');
writeln(
'ArrayList<$className> list = new ArrayList<$className>(jsonArray.size());');
writeln('Iterator<JsonElement> iterator = jsonArray.iterator();');
writeln('while (iterator.hasNext()) {');
writeln(' list.add(fromJson(iterator.next().getAsJsonObject()));');
writeln('}');
writeln('return list;');
});
writeln('}');
});
}
//
// toJson() method, example:
// public JsonObject toJson() {
// JsonObject jsonObject = new JsonObject();
// jsonObject.addProperty("x", x);
// jsonObject.addProperty("y", y);
// return jsonObject;
// }
if (className != 'Outline') {
publicMethod('toJson', () {
writeln('public JsonObject toJson() {');
indent(() {
writeln('JsonObject jsonObject = new JsonObject();');
for (TypeObjectField field in fields) {
if (!isObject(field.type)) {
if (field.optional) {
writeln('if (${javaName(field.name)} != null) {');
indent(() {
_writeOutJsonObjectAddStatement(field);
});
writeln('}');
} else {
_writeOutJsonObjectAddStatement(field);
}
}
}
writeln('return jsonObject;');
});
writeln('}');
});
}
//
// equals() method
//
publicMethod('equals', () {
writeln('@Override');
writeln('public boolean equals(Object obj) {');
indent(() {
writeln('if (obj instanceof $className) {');
indent(() {
writeln('$className other = ($className) obj;');
writeln('return');
indent(() {
List<String> equalsForField = new List<String>();
for (TypeObjectField field in fields) {
equalsForField.add(_getEqualsLogicForField(field, 'other'));
}
if (equalsForField.isNotEmpty) {
write(equalsForField.join(' && \n'));
} else {
write('true');
}
});
writeln(';');
});
writeln('}');
writeln('return false;');
});
writeln('}');
});
//
// containsInclusive(int x)
//
if (className == 'HighlightRegion' ||
className == 'NavigationRegion' ||
className == 'Outline') {
publicMethod('containsInclusive', () {
writeln('public boolean containsInclusive(int x) {');
indent(() {
writeln('return offset <= x && x <= offset + length;');
});
writeln('}');
});
}
//
// contains(int x)
//
if (className == 'Occurrences') {
publicMethod('containsInclusive', () {
writeln('public boolean containsInclusive(int x) {');
indent(() {
writeln('for (int offset : offsets) {');
writeln(' if (offset <= x && x <= offset + length) {');
writeln(' return true;');
writeln(' }');
writeln('}');
writeln('return false;');
});
writeln('}');
});
}
//
// hashCode
//
publicMethod('hashCode', () {
writeln('@Override');
writeln('public int hashCode() {');
indent(() {
writeln('HashCodeBuilder builder = new HashCodeBuilder();');
for (int i = 0; i < fields.length; i++) {
writeln("builder.append(${javaName(fields[i].name)});");
}
writeln('return builder.toHashCode();');
});
writeln('}');
});
//
// toString
//
publicMethod('toString', () {
writeln('@Override');
writeln('public String toString() {');
indent(() {
writeln('StringBuilder builder = new StringBuilder();');
writeln('builder.append(\"[\");');
for (int i = 0; i < fields.length; i++) {
writeln("builder.append(\"${javaName(fields[i].name)}=\");");
write("builder.append(${_getToStringForField(fields[i])}");
if (i + 1 != fields.length) {
// this is not the last field
write(' + \", \"');
}
writeln(');');
}
writeln('builder.append(\"]\");');
writeln('return builder.toString();');
});
writeln('}');
});
if (className == 'Element') {
_writeExtraContentInElementType();
}
//
// getBestName()
//
if (className == 'TypeHierarchyItem') {
publicMethod('getBestName', () {
writeln('public String getBestName() {');
indent(() {
writeln('if (displayName == null) {');
writeln(' return classElement.getName();');
writeln('} else {');
writeln(' return displayName;');
writeln('}');
});
writeln('}');
});
}
});
}
}