private AnonymousClassStructureBuilder generateMethodDelegates(final Class<?> intf, final Decorable decorable, final FactoryController controller) { .extend().publicOverridesMethod("callback", Parameter.of(Message.class, "message")) .append(Stmt.declareVariable("commandType", String.class, Stmt.loadVariable("message").invoke("getCommandType"))) .append(Stmt.declareVariable("methodParms", List.class, Stmt.loadVariable("message").invoke("get", List.class, Stmt.loadLiteral("MethodParms")))); for (final MetaMethod method : mc.getMethods()) { if (ProxyUtil.isMethodInInterface(mc, method) && ProxyUtil.shouldProxyMethod(method)) { final MetaClass[] parameterTypes = Arrays.stream(method.getParameters()).map(p -> p.getType()).toArray(MetaClass[]::new); final Statement[] objects = new Statement[parameterTypes.length]; final BlockBuilder<ElseBlockBuilder> blockBuilder = If .cond(Stmt.loadLiteral(ProxyUtil.createCallSignature(method)).invoke("equals", Stmt.loadVariable("commandType"))); blockBuilder.append(Stmt.declareFinalVariable("instance", intf, controller.contextGetInstanceStmt())); objects[i] = Stmt.castTo(parameterType, Stmt.loadVariable("methodParms").invoke("get", i)); final boolean hasReturnType = !method.getReturnType().isVoid(); final Statement methodInvocation = Stmt.nestedCall(Stmt.loadVariable("instance")).invoke(method.getName(), (Object[]) objects); final Statement invocation = (hasReturnType) ? Stmt.declareFinalVariable("ret", method.getReturnType(), methodInvocation) : methodInvocation; final Statement maybeDestroy = (decorable.isEnclosingTypeDependent()) ? Stmt.loadVariable("context").invoke("destroyInstance", Refs.get("instance")) : EmptyStatement.INSTANCE; final Statement sendResponse = (hasReturnType) ? Stmt.invokeStatic(MessageBuilder.class, "createConversation", Stmt.loadVariable("message")) .invoke("subjectProvided").invoke("with", "MethodReply", Refs.get("ret")) .invoke("noErrorHandling").invoke("sendNowWith", Stmt.invokeStatic(ErraiBus.class, "get")) : EmptyStatement.INSTANCE;
final MetaClass arrayType = toMap.asArrayOf(1); classStructureBuilder.privateField("EMPTY_ARRAY", arrayType).initializesWith(Stmt.newArray(toMap, 0)).finish(); .append(Stmt.loadClassMember("EMPTY_ARRAY").returnValue()) .finish(); Parameter.of(EJValue.class, "a0"), Parameter.of(MarshallingSession.class, "a1")); builder.append(Stmt.loadVariable("this").invoke("lazyInit")); builder.append(Stmt.declareVariable(EJObject.class).named("obj") .initializeWith(loadVariable("a0").invoke("isObject"))); if (toMap.isEnum()) { builder.append(Stmt.declareVariable(toMap).named("entity") .initializeWith(demarshallEnum(loadVariable("obj"), loadVariable("a0"), toMap))); builder.append(If.cond(Bool.isNull(Refs.get("obj"))).append(Stmt.load(null).returnValue()).finish()); builder.append( final MetaClass type = mapping.getType().asBoxed(); BlockBuilder<?> lazyInitMethod = (needsLazyInit(type)) ? initMethod : null; if (type.isArray()) { Parameter.of(toMap, "a0"), Parameter.of(MarshallingSession.class, "a1")); marshallMethodBlock.append(Stmt.loadVariable("this").invoke("lazyInit"));
wrappedListProperty = Stmt.loadVariable(property).assignValue( Cast.to(paramType, agent().invoke("ensureBoundListIsProxied", property, Stmt.loadVariable(property)))); target().invoke(setterMethod.getName(), Cast.to(paramType, Stmt.loadVariable(property))); if (!setterMethod.getReturnType().equals(MetaClassFactory.get(void.class))) { returnValueOfSetter = Stmt.nestedCall(Refs.get(returnValName)).returnValue(); } else { returnValueOfSetter = EmptyStatement.INSTANCE; .append(Stmt.loadVariable(property).assignValue(Cast.to(paramType, Parameter.of(paramType, property)) } else { classBuilder.publicMethod(setterMethod.getReturnType(), setterMethod.getName(), Parameter.of(paramType, property)) .append(loadVariable("this").invoke("changeAndFire", property, Variable.get(property)))
statements.add(declareVariable("binder", DataBinder.class, binderLookup.getValueAccessor())); statements.add(If.isNull(Refs.get("binder")).append( throw_(RuntimeException.class, "@AutoBound data binder for class " + targetClass + " has not been initialized. Either initialize or add @Inject!")).finish()); statements.add(controller.setReferenceStmt(DataBindingUtil.BINDER_VAR_NAME, loadVariable("binder"))); if (componentType.isAssignableTo(Widget.class)) { if (!decorable.get().isAnnotationPresent(Inject.class) && decorable.decorableType().equals(DecorableType.FIELD) && componentType.isDefaultInstantiable()) { Statement widgetInit = Stmt.loadVariable("this").invoke( PrivateAccessUtil.getPrivateFieldAccessorName(decorable.getAsField()), Refs.get("instance"), ObjectBuilder.newInstanceOf(componentType)); statements.add(If.isNull(component).append(widgetInit).finish()); else if (componentType.isAnnotationPresent(JsType.class)) { if (componentType.isAssignableTo(HasValue.class)) { final MetaClass valueType = componentType.getMethod("getValue", new Class[0]).getReturnType(); DataBindingValidator.getPropertyType(binderLookup.getDataModelType(), property)); Statement onKeyUp = Stmt.load(bound.onKeyUp()); statements.add(Stmt.loadVariable("binder").invoke("bind", component, property, conv, loadLiteral(null), onKeyUp)); if (!hasRunForType) { controller.addDestructionStatements(Collections.<Statement> singletonList( nestedCall(controller.getReferenceStmt(DataBindingUtil.BINDER_VAR_NAME, DataBinder.class)).invoke("unbind")));
final String targetVar = "t"; final BlockStatement block = new BlockStatement(); block.addStatement(Stmt.declareFinalVariable(cloneVar, bindable, Stmt.newObject(bindable))); block.addStatement(Stmt.declareFinalVariable(targetVar, bindable, Stmt.loadVariable("this").invoke("unwrap"))); loadVariable(targetVar).invoke(readMethod))); colBlock.append(Stmt.declareFinalVariable(colVarName, type.getErased(), Stmt.newObject(clazz))); colBlock.append(Stmt.declareFinalVariable(colVarName, type.getErased(), Stmt.newObject(type.getErased()))); colBlock.append( Stmt.nestedCall(loadVariable(targetVar).invoke(readMethod)).foreach(elemVarName, Object.class) .append ( If.instanceOf(Refs.get(elemVarName), BindableProxy.class) .append (Stmt.loadVariable(colVarName) .invoke("add", Stmt.castTo(BindableProxy.class, Stmt.loadVariable(elemVarName)).invoke(methodName)) .append(Stmt.loadVariable(colVarName).invoke("add", Refs.get(elemVarName))) colBlock.append(Stmt.loadVariable(cloneVar).invoke(writeMethod, Refs.get(colVarName))); Cast.to ( readMethod.getReturnType(), Stmt.castTo(BindableProxy.class, Stmt.loadVariable("this").invoke(readMethod)).invoke(methodName)
for (final Map.Entry<String, ProxyProperty> entry : entries) { builder.privateField(entry.getValue().getEncodedProperty(), entry.getValue().getType()).finish(); builder.packageMethod(void.class, "$set_" + entry.getKey(), Parameter.of(entry.getValue().getType(), "o")) .append(Stmt.loadVariable(entry.getValue().getEncodedProperty()).assignValue(Refs.get("o"))) .finish(); methodParms.add(Parameter.of(parameters[i].getType().getErased(), "a" + i)); BlockBuilder<ElseBlockBuilder> ifBody = Stmt.create().if_( BooleanExpressionBuilder.create(Stmt.loadVariable(stateVar))); ifBody.appendAll(getAroundInvokeStatements(method)); ifBody.appendAll(getBeforeStatements(method)); statementVars[i] = loadVariable(parms.get(i).getName()); privateAccessStmts[0] = Refs.get(proxyVar); System.arraycopy(statementVars, 0, privateAccessStmts, 1, statementVars.length); ifBody._(loadVariable("this").invoke(PrivateAccessUtil.getPrivateMethodName(method), privateAccessStmts).returnValue()); ifBody._(loadVariable(proxyVar).invoke(method, statementVars).returnValue()); .finish() .else_() ._(Stmt.loadVariable(proxyVar).invoke("equals", Refs.get("o")).returnValue()) .finish()
final MetaClass eventType = parm.getType().asBoxed(); final String parmClassName = eventType.getFullyQualifiedName(); final List<Annotation> annotations = InjectUtil.extractQualifiers(parm); final Annotation[] qualifiers = annotations.toArray(new Annotation[annotations.size()]); AnonymousClassStructureBuilder callBack = Stmt.newObject(callBackType).extend(); callBackBlock = callBack.initialize(); for (final String qualifierName : qualifierNames) { callBackBlock.append(Stmt.loadClassMember("qualifierSet").invoke("add", qualifierName)); callBack = callBackBlock.finish(); if (!isEnclosingTypeDependent) { callbackStatements .add(declareFinalVariable("instance", decorable.getDecorableDeclaringType(), castTo(decorable.getEnclosingInjectable().getInjectedType(), invokeStatic(Factory.class, "maybeUnwrapProxy", controller.contextGetInstanceStmt())))); callbackStatements.add(decorable.call(Refs.get("event"))); if (eventType.isAnnotationPresent(JsType.class)) { subscribeMethod = "subscribeJsType"; callBackBlock = getJsTypeSubscriptionCallback(decorable, controller); destroyStatements.add(controller.getReferenceStmt(subscrVar, Subscription.class).invoke("remove")); } else { initStatements.add(subscribeStatement);
public static void createJavaReflectionMethodInitializerUtilMethod( final ClassStructureBuilder<?> classBuilder) { if (classBuilder.getClassDefinition().getMethod(JAVA_REFL_METH_UTIL_METH, Class.class, String.class, Class[].class) != null) { return; } classBuilder.privateMethod(Method.class, JAVA_REFL_METH_UTIL_METH).modifiers(Modifier.Static) .parameters(DefParameters.of(Parameter.of(Class.class, "cls"), Parameter.of(String.class, "name"), Parameter.of(Class[].class, "parms"))) .body() ._(Stmt.try_() ._(Stmt.declareVariable("meth", Stmt.loadVariable("cls").invoke("getDeclaredMethod", Stmt.loadVariable("name"), Stmt.loadVariable("parms")))) ._(Stmt.loadVariable("meth").invoke("setAccessible", true)) ._(Stmt.loadVariable("meth").returnValue()) .finish() .catch_(Throwable.class, "e") ._(Stmt.loadVariable("e").invoke("printStackTrace")) ._(Stmt.throw_(RuntimeException.class, Refs.get("e"))) .finish()) .finish(); }
.define("Dynamic" + fullyQualifiedClassNameToCamelCase(validator.getFullyQualifiedName()), validator) .publicScope() .implementsInterface(parameterizedAs(GeneratedDynamicValidator.class, typeParametersOf(valueType))) finalOf(parameterizedAs(Map.class, typeParametersOf(String.class, Object.class)), "parameters"), finalOf(valueType, "value")) .body(); .append(loadVariable("this").invoke("initialize", annoImpl)) .append(if_(Bool.expr(loadVariable("this").invoke("isValid", loadVariable("value"), castTo(ConstraintValidatorContext.class, loadLiteral(null))))) .append(invokeStatic(Collections.class, "emptySet").returnValue()) .finish().else_() .append(Stmt.declareVariable("paramMessage", String.class, castTo(String.class, loadVariable("parameters").invoke("get", Stmt.loadLiteral("message"))))) .append(Stmt.loadVariable("paramMessage").assignValue( new TernaryStatement(Bool.isNotNull(Stmt.loadVariable("paramMessage")), Stmt.loadVariable("paramMessage") .invoke("replaceAll", Stmt.loadLiteral("{"), Stmt.loadLiteral("")) .invoke("replaceAll", Stmt.loadLiteral("}"), Stmt.loadLiteral("")) ,Stmt.loadLiteral("")))) .append(Stmt.declareFinalVariable("message", String.class, Stmt.loadVariable("messageResolver").invoke("get", Refs.get("paramMessage")))) .append(invokeStatic(Collections.class, "singleton", createConstraintViolation()).returnValue()) .finish()) .finish();
@Override public void createReadableField(final MetaClass type, final ClassStructureBuilder<?> classBuilder, final MetaField field, final Modifier[] modifiers) { final String cachedField = initCachedField(classBuilder, field); final String getterName = getReflectionFieldGetterName(field); final MethodCommentBuilder<? extends ClassStructureBuilder<?>> methodBuilder = classBuilder.privateMethod(field.getType().getErased(), PrivateAccessUtil.getPrivateFieldAccessorName(field)); if (!field.isStatic()) { methodBuilder.parameters( DefParameters.fromParameters( Parameter.of(field.getDeclaringClass().getErased(), "instance") ) ); } methodBuilder.modifiers(modifiers) .body() ._(Stmt.try_() ._(Stmt.nestedCall(Cast.to(field.getType().getErased(), Stmt.loadVariable(cachedField) .invoke(getterName, field.isStatic() ? null : Refs.get("instance")))).returnValue()) .finish() .catch_(Throwable.class, "e") ._(Stmt.loadVariable("e").invoke("printStackTrace")) ._(Stmt.throw_(RuntimeException.class, Refs.get("e"))) .finish()) .finish(); }
private BlockBuilder<AnonymousClassStructureBuilder> getJsTypeSubscriptionCallback(final Decorable decorable, final FactoryController controller) { final MetaParameter parm = decorable.getAsParameter(); final MetaClass eventType = parm.getType().asBoxed(); final String parmClassName = eventType.getFullyQualifiedName(); final MetaClass callBackType = parameterizedAs(JsTypeEventObserver.class, typeParametersOf(eventType)); final AnonymousClassStructureBuilder callBack = Stmt.newObject(callBackType).extend(); BlockBuilder<AnonymousClassStructureBuilder> callBackBlock; final List<Statement> fireEventStmts = new ArrayList<>(); if (!decorable.isEnclosingTypeDependent()) { fireEventStmts.add(Stmt.declareFinalVariable("instance", decorable.getEnclosingInjectable().getInjectedType(), Stmt.invokeStatic(Factory.class, "maybeUnwrapProxy", controller.contextGetInstanceStmt()))); } fireEventStmts.add(decorable.call(Refs.get("event"))); callBackBlock = callBack.publicOverridesMethod("onEvent", Parameter.finalOf(eventType, "event")) .appendAll(fireEventStmts) .finish() .publicOverridesMethod("toString") ._(Stmt.load("JsTypeObserver: " + parmClassName).returnValue()); return callBackBlock; } }
final BlockBuilder<?> initMethod) { if (!context.canMarshal(toType.getFullyQualifiedName())) { throw new NoAvailableMarshallerException(toType.getName()); builder.append( If.isNull(loadVariable("a0")) .append(Stmt.load("null").returnValue()).finish() ); if (toMap.isEnum()) { builder.append(Stmt.load(marshallEnum(loadVariable("a0"), toMap)).returnValue()); return; builder.append(Stmt.declareFinalVariable("ref", boolean.class, Stmt.loadVariable("a1").invoke("hasObject", Refs.get("a0")))); json = Str.expr(json, StringOperator.Concat, SerializationParts.OBJECT_ID); json = Str.expr(json, StringOperator.Concat, "\":\""); json = Str.expr(json, StringOperator.Concat, loadVariable("a1").invoke("getObject", Stmt.loadVariable("a0"))); json = Str.expr(json, StringOperator.Concat, "\""); concat = Str.expr(concat, StringOperator.Concat, loadVariable(MarshallingGenUtil.getVarName(targetType)) .invoke("marshall", valueStatement, loadVariable("a1")));
private static void bindHandlingMethod(final Decorable decorable, final FactoryController controller, final MetaParameter parameter) { final Statement elementAccessor; if (MetaClassFactory.get(Element.class).isAssignableFrom(parameter.getType())) { elementAccessor = Refs.get("element"); else if (MetaClassFactory.get(Style.class).isAssignableFrom(parameter.getType())) { elementAccessor = Stmt.loadVariable("element").invoke("getStyle"); final boolean enclosingTypeIsDependent = decorable.isEnclosingTypeDependent(); if (!enclosingTypeIsDependent) { bindExecStmts.add(declareFinalVariable("instance", decorable.getEnclosingInjectable().getInjectedType(), castTo(decorable.getEnclosingInjectable().getInjectedType(), invokeStatic(Factory.class, "maybeUnwrapProxy", controller.contextGetInstanceStmt())))); final List<Statement> destructionStmts = new ArrayList<Statement>(); initStmts.add(declareFinalVariable(hanldeVarName, parameterizedAs(RefHolder.class, typeParametersOf(BindingRegistrationHandle.class)), newObject(RefHolder.class))); initStmts.add(loadVariable(hanldeVarName).invoke("set", invokeStatic(StyleBindingsRegistry.class, "get") .invoke("addStyleBinding", decorable.getAnnotation().annotationType(), bindExec))); .castTo(BindingRegistrationHandle.class, controller.getReferenceStmt(registrationHandleVar, RefHolder.class).invoke("get")) .invoke("cleanup")); if (enclosingTypeIsDependent) { addCleanup(decorable, controller, destructionStmts);
statements.add(Stmt.declareFinalVariable("objectClass", Class.class, Stmt.loadLiteral(Object.class))); Stmt.newObject(QueryParamInitCallback.class).extend().publicOverridesMethod("getQueryParams"); queryParamCallback.append(Stmt.declareFinalVariable("paramsMap", Map.class, Stmt.newObject(HashMap.class))); if (val.startsWith("{") && val.endsWith("}")) { String fieldName = val.substring(1, val.length() - 1); MetaField field = decorable.getDecorableDeclaringType().getInheritedField(fieldName); fieldValueStmt = InjectUtil.getPublicOrPrivateFieldValue(controller, field); fieldValueStmt = Stmt.loadLiteral(val); queryParamCallback.append(Stmt.loadVariable("paramsMap").invoke("put", param.name(), fieldValueStmt)); queryParamCallback.append(Stmt.loadVariable("paramsMap").returnValue()); statements.add(Stmt.declareFinalVariable("paramsCallback", Stmt.nestedCall(syncWorkerRef).invoke("addSyncCallback", createSyncCallback(decorable))); statements.add( Stmt.nestedCall(syncWorkerRef).invoke("start", Refs.get("instance"), Stmt.loadVariable("paramsCallback")));
wrapperDefParms.add(Parameter.of(method.getDeclaringClass().getErased(), "instance")); args[i++] = Refs.get(p.getName()); .body(); final BlockBuilder<CatchBlockBuilder> tryBuilder = Stmt.try_(); final ContextualStatementBuilder statementBuilder = Stmt.loadVariable(cachedMethod) .invoke("invoke", method.isStatic() ? null : Refs.get("instance"), args); if (method.getReturnType().isVoid()) { tryBuilder._(statementBuilder); tryBuilder._(Stmt.castTo(method.getReturnType().asBoxed(), statementBuilder).returnValue()); body._(tryBuilder .finish() .catch_(Throwable.class, "e") ._(Stmt.loadVariable("e").invoke("printStackTrace")) ._(Stmt.throw_(RuntimeException.class, Refs.get("e"))) .finish()) .finish();
.initializesWith(Stmt.newObject(mapStringAnnoComp)).finish(); constrBuilder._(Stmt.loadVariable(COMPARATOR_MAP_VAR) .invoke("put", MC_annotationClass.getFullyQualifiedName(), generateComparatorFor(MC_annotationClass, methods))); Parameter.of(annotationClazz, "a1"), Parameter.of(annotationClazz, "a2")) .body() ._(If.cond(invokeStatic(QualifierUtil.class, "isSameType", Refs.get("a1"), Refs.get("a2"))) ._( If.cond(Stmt.loadVariable(COMPARATOR_MAP_VAR).invoke("containsKey", Stmt.loadVariable("a1").invoke("annotationType").invoke("getName"))) ._(Stmt.castTo(AnnotationComparator.class, Stmt.loadVariable(COMPARATOR_MAP_VAR) .invoke("get", Stmt.loadVariable("a1").invoke("annotationType").invoke("getName")) ).invoke("isEqual", Refs.get("a1"), Refs.get("a2")).returnValue()) .finish() .else_() builder.publicMethod(int.class, "hashCodeOf", Parameter.of(Annotation.class, "a1")) .body() ._( ._(Stmt.castTo(AnnotationComparator.class, Stmt.loadVariable(COMPARATOR_MAP_VAR) .invoke("get", Stmt.loadVariable("a1").invoke("annotationType").invoke("getName")) ).invoke("hashCodeOf", Refs.get("a1")).returnValue()) .finish() .else_()
for (final MetaMethod method : bindable.getMethods()) { final String methodName = method.getName(); final List<Statement> parmVars = new ArrayList<>(); for (int i = 0; i < parms.length; i++) { parmVars.add(Stmt.loadVariable(parms[i].getName())); final MetaClass type = getTypeOrFirstUpperBound(method.getGenericParameterTypes()[i], method); if (type == null) return; parms[i] = Parameter.of(type, parms[i].getName()); callOnTarget = Stmt.declareFinalVariable(returnValName, returnType, target().invoke(method, parmVars.toArray())); returnValue = Stmt.nestedCall(Refs.get(returnValName)).returnValue(); callOnTarget = target().invoke(method, parmVars.toArray()); returnValue = EmptyStatement.INSTANCE; .publicMethod(returnType, methodName, parms) .append(callOnTarget) .append(agent().invoke("updateWidgetsAndFireEvents")) .append(returnValue) .finish();
final String templateVarName = "templateFor" + decorable.getDecorableDeclaringType().getName(); final Optional<String> resolvedStylesheetPath = getResolvedStyleSheetPath(getTemplateStyleSheetPath(declaringClass), declaringClass); final boolean lessStylesheet = resolvedStylesheetPath.filter(path -> path.endsWith(".less")).isPresent(); initStmts.add(declareVariable(constructed.get(declaringClass)).named(templateVarName) .initializeWith(invokeStatic(GWT.class, "create", constructed.get(declaringClass)))); controller.addFactoryInitializationStatements(singletonList(castTo(constructed.get(declaringClass), invokeStatic(GWT.class, "create", constructed.get(declaringClass))).invoke("getStyle") .invoke("ensureInjected"))); final String parentOfRootTemplateElementVarName = "parentElementForTemplateOf" + decorable.getDecorableDeclaringType().getName(); initStmts.add(Stmt .declareVariable(Element.class) Stmt.invokeStatic(TemplateUtil.class, "getRootTemplateParentElement", (customProvider) ? Variable.get("template") : Stmt.loadVariable(templateVarName).invoke("getContents").invoke("getText"), getTemplateFileName(declaringClass), getTemplateFragmentName(declaringClass)))); final Statement component = Refs.get("instance");
@Override public void makeConstructorAccessible(final ClassStructureBuilder<?> classBuilder, final MetaConstructor constructor) { final DefParameters methodDefParms = DefParameters.from(constructor); final String cachedMethod = initCachedMethod(classBuilder, constructor); final Object[] args = new Object[methodDefParms.getParameters().size()]; int i = 0; for (final Parameter p : methodDefParms.getParameters()) { args[i++] = Refs.get(p.getName()); } final BlockBuilder<? extends ClassStructureBuilder> body = classBuilder.publicMethod(constructor.getReturnType(), PrivateAccessUtil.getPrivateMethodName(constructor)) .parameters(methodDefParms) .modifiers(Modifier.Static) .body(); final Statement tryBuilder = Stmt.try_() .append( Stmt.nestedCall( Stmt.castTo(constructor.getReturnType(), Stmt.loadVariable(cachedMethod).invoke("newInstance", (Object) args))).returnValue()) .finish() .catch_(Throwable.class, "e") .append(Stmt.loadVariable("e").invoke("printStackTrace")) .append(Stmt.throw_(RuntimeException.class, Refs.get("e"))) .finish(); body.append(tryBuilder).finish(); }
final boolean explicitStyleSheetPresent = styleSheetPath.filter(path -> Thread.currentThread().getContextClassLoader().getResource(path) != null).isPresent(); if (declaringClass.isAssignableTo(Composite.class)) { logger.warn("The @Templated class, {}, extends Composite. This will not be supported in future versions.", declaringClass.getFullyQualifiedName()); throw new GenerationException("@Templated class [" + declaringClass.getFullyQualifiedName() + "] declared a stylesheet [" + styleSheetPath + "] that could not be found."); Stmt.invokeStatic(TemplateUtil.class, "provideTemplate", templateProvider, getTemplateUrl(declaringClass), Stmt.newObject(TemplateRenderingCallback.class) .extend() .publicOverridesMethod("renderTemplate", Parameter.of(String.class, "template", true)) .appendAll(initStmts) .finish() .finish()); controller.addInitializationStatementsToEnd(Collections.<Statement>singletonList(invokeStatic(StyleBindingsRegistry.class, "get") .invoke("updateStyles", Refs.get("instance"))));