/*
* Copyright 2008 Google Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License"); you may not
* use this file except in compliance with the License. You may obtain a copy of
* the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* License for the specific language governing permissions and limitations under
* the License.
*/
package com.google.gwt.dev.jjs.impl;
import com.google.gwt.dev.PropertyAndBindingInfo;
import com.google.gwt.dev.cfg.BindingProperty;
import com.google.gwt.dev.cfg.PermutationProperties;
import com.google.gwt.dev.jjs.InternalCompilerException;
import com.google.gwt.dev.jjs.SourceInfo;
import com.google.gwt.dev.jjs.SourceOrigin;
import com.google.gwt.dev.jjs.ast.AccessModifier;
import com.google.gwt.dev.jjs.ast.Context;
import com.google.gwt.dev.jjs.ast.JBlock;
import com.google.gwt.dev.jjs.ast.JCaseStatement;
import com.google.gwt.dev.jjs.ast.JClassType;
import com.google.gwt.dev.jjs.ast.JExpression;
import com.google.gwt.dev.jjs.ast.JMethod;
import com.google.gwt.dev.jjs.ast.JMethodBody;
import com.google.gwt.dev.jjs.ast.JMethodCall;
import com.google.gwt.dev.jjs.ast.JModVisitor;
import com.google.gwt.dev.jjs.ast.JPermutationDependentValue;
import com.google.gwt.dev.jjs.ast.JProgram;
import com.google.gwt.dev.jjs.ast.JReferenceType;
import com.google.gwt.dev.jjs.ast.JReturnStatement;
import com.google.gwt.dev.jjs.ast.JSwitchStatement;
import com.google.gwt.dev.jjs.ast.RuntimeConstants;
import com.google.gwt.thirdparty.guava.common.base.Function;
import com.google.gwt.thirdparty.guava.common.base.Joiner;
import com.google.gwt.thirdparty.guava.common.collect.FluentIterable;
import com.google.gwt.thirdparty.guava.common.collect.Lists;
import com.google.gwt.thirdparty.guava.common.collect.Maps;
import com.google.gwt.thirdparty.guava.common.collect.Multimap;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.Set;
/**
* Replaces any "GWT.create()" calls with a new expression for the actual result of the deferred
* binding decision and System.getProperty() with the actual value for that property.
* <p>
* When properties are collapsed (e.g. in soft permutations) a method is create that resolves
* the value at runtime.
* </p>
*
*/
public class ResolvePermutationDependentValues {
private class ValueReplacer extends JModVisitor {
@Override
public void endVisit(JPermutationDependentValue x, Context ctx) {
if (x.isTypeRebind()) {
ctx.replaceMe(rebindClassExpression(x));
return;
}
assert x.isProperty();
ctx.replaceMe(propertyValueExpression(x));
}
private JExpression propertyValueExpression(JPermutationDependentValue x) {
List<String> propertyValues = props.getConfigurationProperties().getStrings(x.getRequestedValue());
String propertyValue = propertyValues.isEmpty() ? null : Joiner.on(",").join(propertyValues);
if (propertyValue != null) {
// It is a configuration property.
return program.getLiteral(x.getSourceInfo(), propertyValue);
}
if (isSoftPermutationProperty(x.getRequestedValue())) {
JMethod method = getOrCreateSoftPropertyMethod(x.getSourceInfo(), x.getRequestedValue());
return new JMethodCall(x.getSourceInfo(), null, method);
}
propertyValue = commonPropertyAndBindingInfo.getPropertyValue(x.getRequestedValue());
if (propertyValue != null) {
return program.getLiteral(x.getSourceInfo(), propertyValue);
}
return x.getDefaultValueExpression();
}
private JExpression rebindClassExpression(JPermutationDependentValue x) {
if (isSoftTypeRebind(x.getRequestedValue())) {
JMethod method = getOrCreateTypeRebindMethod(x.getSourceInfo(), x.getRequestedValue(),
x.getResultValues(), x.getResultExpressions());
return new JMethodCall(x.getSourceInfo(), null, method);
}
return computeInstantiationExpression(x);
}
}
public static boolean exec(JProgram program, PermutationProperties props,
List<PropertyAndBindingInfo> propertyAndBindingInfo) {
return new ResolvePermutationDependentValues(program, props, propertyAndBindingInfo).execImpl();
}
private final JProgram program;
private final PermutationProperties props;
private final Set<String> bindingPropertyNames;
private final List<PropertyAndBindingInfo> permutationPropertyAndBindingInfo;
private final PropertyAndBindingInfo commonPropertyAndBindingInfo;
private final JClassType holderType;
private final JMethod permutationIdMethod;
private final Map<String, JMethod> softPermutationMethods = Maps.newHashMap();
private ResolvePermutationDependentValues(JProgram program, PermutationProperties props,
List<PropertyAndBindingInfo> gwtCreateAnswers) {
this.program = program;
this.permutationPropertyAndBindingInfo = gwtCreateAnswers;
this.props = props;
this.bindingPropertyNames = FluentIterable.from(props.getBindingProperties()).transform(
new Function<BindingProperty, String>() {
@Override
public String apply(BindingProperty bindingProperty) {
return bindingProperty.getName();
}
}).toSet();
this.commonPropertyAndBindingInfo = PropertyAndBindingInfo.getCommonAnswers(gwtCreateAnswers);
this.holderType = (JClassType) program.getIndexedType("CollapsedPropertyHolder");
this.permutationIdMethod = program.getIndexedMethod(
RuntimeConstants.COLLAPSED_PROPERTY_HOLDER_GET_PERMUTATION_ID);
}
public JExpression computeInstantiationExpression(JPermutationDependentValue x) {
String reqType = x.getRequestedValue();
// Rebinds are always on a source type name.
String reboundClassName = commonPropertyAndBindingInfo.getReboundType(reqType);
if (reboundClassName == null) {
// The fact that we already compute every rebind permutation before
// compiling should prevent this case from ever happening in real life.
//
throw new InternalCompilerException("Unexpected failure to rebind '" + reqType + "'");
}
assert program.getFromTypeMap(reboundClassName) != null;
int index = x.getResultValues().indexOf(reboundClassName);
if (index == -1) {
throw new InternalCompilerException("No matching rebind result in all rebind results!");
}
return x.getResultExpressions().get(index);
}
private boolean execImpl() {
ValueReplacer valueReplacer = new ValueReplacer();
valueReplacer.accept(program);
return valueReplacer.didChange();
}
private boolean isSoftTypeRebind(String requestType) {
return !commonPropertyAndBindingInfo.containsType(requestType);
}
private boolean isSoftPermutationProperty(String propertyName) {
return bindingPropertyNames.contains(propertyName) &&
!commonPropertyAndBindingInfo.containsProperty(propertyName);
}
private JMethod getOrCreateSoftPropertyMethod(final SourceInfo info, String propertyName) {
JMethod toReturn = softPermutationMethods.get(propertyName);
if (toReturn != null) {
return toReturn;
}
Multimap<String, Integer> resultsToPermutations = PropertyAndBindingInfo
.getPermutationIdsByPropertyName(permutationPropertyAndBindingInfo, propertyName);
List<String> propertyValues = Lists.newArrayList(resultsToPermutations.keySet());
return createReboundValueSelectorMethod(info, "property_", propertyName,
program.getTypeJavaLangString(), propertyValues,
FluentIterable.from(propertyValues).transform(
new Function<String, JExpression>() {
@Override
public JExpression apply(String s) {
return program.getLiteral(info, s);
}
}).toList(), resultsToPermutations);
}
private JMethod getOrCreateTypeRebindMethod(SourceInfo info, String requestType,
List<String> resultTypes, List<JExpression> instantiationExpressions) {
assert resultTypes.size() == instantiationExpressions.size();
JMethod toReturn = softPermutationMethods.get(requestType);
if (toReturn != null) {
return toReturn;
}
Multimap<String, Integer> resultsToPermutations = PropertyAndBindingInfo
.getPermutationIdsByRequestTypes(permutationPropertyAndBindingInfo, requestType);
return createReboundValueSelectorMethod(info, "create_", requestType,
program.getTypeJavaLangObject().strengthenToNonNull(), resultTypes,
instantiationExpressions, resultsToPermutations);
}
private JMethod createReboundValueSelectorMethod(SourceInfo info, String prefix,
String parameterType, JReferenceType returntype, List<String> results,
List<JExpression> resultExpressions, Multimap<String, Integer> resultsToPermutations) {
// Pick the most-used result type to emit less code
String mostUsed = mostUsedValue(resultsToPermutations);
assert mostUsed != null;
JMethod toReturn;
info = info.makeChild(SourceOrigin.UNKNOWN);
// c_g_g_d_c_i_DOMImpl
toReturn =
new JMethod(info, prefix + parameterType.replace("_", "_1").replace('.', '_'), holderType,
returntype, false, true, true, AccessModifier.PUBLIC);
toReturn.setBody(new JMethodBody(info));
holderType.addMethod(toReturn);
toReturn.freezeParamTypes();
info.addCorrelation(info.getCorrelator().by(toReturn));
softPermutationMethods.put(parameterType, toReturn);
// Used in the return statement at the end
JExpression mostUsedExpression = null;
JBlock switchBody = new JBlock(info);
for (int i = 0, j = results.size(); i < j; i++) {
String resultType = results.get(i);
JExpression expression = resultExpressions.get(i);
Collection<Integer> permutations = resultsToPermutations.get(resultType);
if (permutations.isEmpty()) {
// This rebind result is unused in this permutation
continue;
} else if (resultType.equals(mostUsed)) {
// Save off the fallback expression and go onto the next type
mostUsedExpression = expression;
continue;
}
for (int permutationId : permutations) {
// case 33:
switchBody.addStmt(new JCaseStatement(info, program.getLiteralInt(permutationId)));
}
// return new FooImpl();
switchBody.addStmt(expression.makeReturnStatement());
}
assert switchBody.getStatements().size() > 0 : "No case statement emitted "
+ "for supposedly soft-rebind " + parameterType;
// switch (CollapsedPropertyHolder.getPermutationId()) { ... }
JSwitchStatement sw =
new JSwitchStatement(info, new JMethodCall(info, null, permutationIdMethod), switchBody);
// return new FallbackImpl(); at the very end.
assert mostUsedExpression != null : "No most-used expression";
JReturnStatement fallbackReturn = mostUsedExpression.makeReturnStatement();
JMethodBody body = (JMethodBody) toReturn.getBody();
body.getBlock().addStmt(sw);
body.getBlock().addStmt(fallbackReturn);
return toReturn;
}
private String mostUsedValue(Multimap<String, Integer> resultsToPermutations) {
String mostUsed = null;
int max = 0;
for (String key : resultsToPermutations.keySet()) {
int size = resultsToPermutations.get(key).size();
if (size > max) {
max = size;
mostUsed = key;
}
}
return mostUsed;
}
}