Example usage for com.google.gwt.dev.jjs SourceOrigin UNKNOWN

Introduction

In this page you can find the example usage for com.google.gwt.dev.jjs SourceOrigin UNKNOWN.

Prototype

SourceOrigin UNKNOWN

To view the source code for com.google.gwt.dev.jjs SourceOrigin UNKNOWN.

Click Source Link

Usage

From source file:xapi.dev.inject.MagicMethods.java

License:Open Source License

/**
 * Replaces a call from {@link X_Inject#singletonAsync(Class, xapi.util.api.ReceivesValue)} by first a)
 * generating an async provider, and then b) sending the value receiver into the async provider as a
 * callback. See the {@link AsyncProxy} class and {@link AsyncInjectionGenerator} for implementation.
 *
 * @param logger - The logger to log to.
 * @param methodCall - The method call we are overwriting
 * @param currentMethod - The encapsulated method itself
 * @param context - The method call context, so you can insert clinits / whatnot
 * @param ast - A view over UnifyAst, exposing our basic needs
 * @return - A JExpression to replace this method call with
 * @throws UnableToCompleteException//from  w w w.  j  a  v  a  2 s  . c  om
 */
public static JExpression rebindSingletonAsync(TreeLogger logger, JMethodCall methodCall, JMethod currentMethod,
        Context context, UnifyAstView ast) throws UnableToCompleteException {
    assert (methodCall.getArgs().size() == 2);
    JExpression classParam = methodCall.getArgs().get(0);
    JExpression receiverParam = methodCall.getArgs().get(1);
    if (!(classParam instanceof JClassLiteral)) {
        ast.error(methodCall,
                "Only class literals may be used as arguments to X_Inject.singletonAsync; you sent "
                        + classParam.getClass() + " - " + classParam);
        return null;
    }

    logger.log(logLevel(),
            receiverParam.toString() + " : " + receiverParam.getClass() + " : " + receiverParam.toSource());
    JClassLiteral classLiteral = (JClassLiteral) classParam;
    JDeclaredType answerType = injectSingletonAsync(logger, classLiteral, methodCall, ast);

    JDeclaredType receiverType = ast.searchForTypeBySource("xapi.util.api.ReceivesValue");
    for (JMethod method : receiverType.getMethods()) {
        if (method.getName().equals("set")) {

            SourceInfo info = methodCall.getSourceInfo().makeChild(SourceOrigin.UNKNOWN);
            JExpression result;
            result = JGwtCreate.createInstantiationExpression(methodCall.getSourceInfo(),
                    (JClassType) answerType);
            if (result == null) {
                ast.error(methodCall,
                        "Rebind result '" + answerType + "' has no default (zero argument) constructors");
                return null;
            }
            JMethodCall call = new JMethodCall(info, result, method);
            call.addArg(receiverParam);
            if (logger.isLoggable(logLevel())) {
                TreeLogger branch = logger.branch(logLevel(), "Generated asynchronous magic singleton: ");
                for (String str : call.toSource().split("\n")) {
                    branch.log(logLevel(), str);
                }
            }
            return call;
        }
    }
    throw new InternalCompilerException("Unable to generate asynchronous class injector");
}

---

From source file:xapi.dev.inject.MagicMethods.java

License:Open Source License

private static JExpression injectSingleton(TreeLogger logger, JClassLiteral classLiteral, JNode x,
        UnifyAstView ast) throws UnableToCompleteException {
    // check for cached result.

    // inject our provider class
    JDeclaredType type = (JDeclaredType) classLiteral.getRefType();
    if (cachedProviders.containsKey(type))
        return cachedProviders.get(type);
    JExpression expr = injectLazySingleton(logger, classLiteral, x, type, ast);
    String[] names = type.getShortName().split("[$]");

    String answer = classLiteral.getRefType().getName();
    answer = answer.substring(0, answer.lastIndexOf('.') + 1) + "impl.SingletonFor_" + names[names.length - 1];

    JDeclaredType enclosing = ast.searchForTypeBySource(answer);
    JDeclaredType lazyProvider = ast.searchForTypeBySource(SingletonProvider.class.getName());
    for (JMethod method : lazyProvider.getMethods()) {
        if (method.getName().equals("get")) {
            // Create a new method for each singleton to access the desired provider
            SourceInfo info = null;// w w w . j  a v  a  2 s  .c om
            JMethod getSingleton = null;
            String targetName = "singleton" + type.getShortName().replaceAll("[$]", "_");
            for (JMethod existingMethod : enclosing.getMethods()) {
                if (existingMethod.getName().equals(existingMethod)) {
                    getSingleton = existingMethod;
                    info = getSingleton.getSourceInfo();
                    logger.log(logLevel(), "Reusing generated method " + getSingleton.toSource());
                    break;
                }
            }
            if (getSingleton == null) {

                info = expr.getSourceInfo().makeChild(SourceOrigin.UNKNOWN);
                JMethodBody body = new JMethodBody(info);
                getSingleton = new JMethod(info, targetName, enclosing, type, false, true, true,
                        AccessModifier.PRIVATE);
                // insert our generated method into the enclosing type; needed for super dev mode
                enclosing.addMethod(getSingleton);

                // freeze this method
                getSingleton.setBody(body);
                getSingleton.freezeParamTypes();
                getSingleton.setSynthetic();
                info.addCorrelation(info.getCorrelator().by(getSingleton));

                JMethodCall call = new JMethodCall(info, expr, method);
                JReturnStatement value = new JReturnStatement(x.getSourceInfo(), call);
                if (enclosing.getClinitTarget() != null) {
                    JDeclaredType clinit = enclosing.getClinitTarget();
                    JMethod clinitMethod = clinit.getMethods().get(0);
                    assert (JProgram.isClinit(clinitMethod));
                    JMethodCall doClinit = new JMethodCall(clinit.getSourceInfo(), null, clinitMethod);
                    body.getBlock().addStmt(doClinit.makeStatement());
                }
                body.getBlock().addStmt(value);
                if (logger.isLoggable(Type.DEBUG)) {
                    logger = logger.branch(Type.DEBUG, "Generated magic singleton: ");
                    for (String str : getSingleton.toSource().split("\n")) {
                        logger.branch(Type.DEBUG, str);
                    }
                }
            }
            expr = new JMethodCall(info, null, getSingleton);
            cachedProviders.put(type, expr);
            return expr;
        }
    }
    throw new InternalCompilerException("Unable to generate synchronous injected class access");
}

---