dev/core/src/com/google/gwt/dev/jjs/impl/ResolvePermutationDependentValues.java - gwt - Git at Google

 /*
  * 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;
   }
 }
	/*
	* 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;
	}
	}