Refine search
if (m.isMethod() != null) { stub.isMethod = true; stub.returnType = getType(m.isMethod().getReturnType()); stub.isStatic = m.isMethod().isStatic(); stub.isAbstract = m.isMethod().isAbstract(); stub.isNative = m.isMethod().isAbstract(); stub.isFinal = m.isMethod().isFinal(); } else { if (m.isPrivate() || m.isDefaultAccess()) { logger.log(Type.INFO, "Skipping non-visible constructor for class " + c.getName()); continue; if (m.getEnclosingType().isFinal() && !m.isPublic()) { logger.log(Type.INFO, "Skipping non-public constructor for final class" + c.getName()); continue; pbn("new Parameter[] {"); for (JParameter p : m.getParameters()) { stub.parameterTypes.add(getType(p.getType())); stub.jnsi += p.getType().getErasedType().getJNISignature(); String paramName = (p.getName() + "__" + p.getType().getErasedType().getJNISignature()).replaceAll( "[/;\\[\\]]", "_"); String paramInstantiation = "new Parameter(\"" + p.getName() + "\", " + getType(p.getType()) + ", \"" + p.getType().getJNISignature() + "\")"; parameterName2ParameterInstantiation.put(paramName, paramInstantiation); pbn(paramName + "(), ");
String defaultValue = null; if (param.getType().isPrimitive() != null) { defaultValue = param.getType().isPrimitive().getUninitializedFieldExpression(); String value = element.consumeAttributeWithDefault(param.getName(), defaultValue, param.getType()); args[index] = value;
unfilledRequiredParams.put(param.getName(), param.getType()); "In %s, cannot apply message attribute to non-string " + "constructor argument %s.", paramType.getSimpleSourceName(), key); } else { JMethod setter = ownerFieldClass.getSetter(key); JParameter[] params = setter == null ? null : setter.getParameters(); || !isString(writer, params[0].getType())) { writer.die(elem, "No method found to apply message attribute %s", key); } else { if (value == null) { writer.die(elem, "Unable to parse %s as constructor argument " + "of type %s", attribute, paramType.getSimpleSourceName()); String addMethod = ADD_PROPERTY_TO_SETTER_MAP.get(propertyName); JType stringType = writer.getOracle().findType(String.class.getName()); if (ownerFieldClass.getRawType().findMethod(addMethod, new JType[]{stringType}) != null) { String n = attribute.getName(); String[] value = elem.consumeStringArrayAttribute(n);
throw new MissingResourceException(key, resourceList); PluralCount pluralCount = params[i].getAnnotation(PluralCount.class); Select select = params[i].getAnnotation(Select.class); if (pluralCount != null && select != null) { throw error(logger, params[i].getName() + " cannot be both @PluralCount" + " and @Select"); logger.log(TreeLogger.ERROR,"No default form for method " + m.getName() ListAccessor listAccessor = null; int listArgNum = argChunk.getArgumentNumber(); JType listType = params[listArgNum].getType(); JClassType classType = listType.isInterface(); JType elemType = null; if (classType != null) { if ("java.util.List".equals( classType.getErasedType().getQualifiedSourceName())) { listAccessor = new ListAccessorList(listArgNum); } else { logger.log(TreeLogger.ERROR, "Parameters formatted as lists " + "must be declared as java.util.List or arrays in " + m.getEnclosingType().getSimpleSourceName() + "." Optional optional = params[i].getAnnotation(Optional.class); Select select = params[i].getAnnotation(Select.class); if (optional == null && select == null) { throw error(logger, "Required argument " + i + " not present: "
private static boolean typeMatches(TreeLogger logger, Annotation anno, JClassType exists) throws UnableToCompleteException { final boolean doLog = logger.isLoggable(logLevel); if (doLog) { logger.log(logLevel, "Checking if annotation "+anno.getClass().getName()+" equals "+exists.getQualifiedSourceName()); logger.log(logLevel, anno.getClass().getName()+": "+ anno.toString()); logger.log(logLevel, exists.getQualifiedSourceName()+": "+ exists.toString()); for (JMethod existingMethod : exists.getMethods()) { if (existingMethod.isPublic() && existingMethod.getEnclosingType() == exists) { existingMethods.put(existingMethod.getName(), existingMethod); JParameter existingParam = existingParams[i]; Class<?> annoParam = annoParams[i]; if (!existingParam.getType().getQualifiedSourceName() .equals(annoParam.getCanonicalName())) { if (doLog) { logger.log(logLevel, "Annotations don't match for " + anno.annotationType().getName()+ "." + m.getName()+"(); "+ "parameter "+ existingParam.getName() +" type has changed " + "from " +existingParam.getType().getQualifiedSourceName()+" to " + annoParam.getCanonicalName()+".");
w.println(); JMethod[] methods = requestedType.getMethods(); w.println( (i > 0 ? ", " : "") + "\"" + methods[i].getName() + "\"" ); w.println( "};" ); JParameter[] params = method.getParameters(); JClassType cbType = typeOracle.findType( params[params.length - 1].getType().getQualifiedSourceName() ); if( cbType == null ) w.println( "*** ERROR : Unable to find callback type : " + params[params.length - 1].getType().getQualifiedSourceName() ); return; JType returnType = params[params.length - 1].getType(); JParameterizedType returnTypeParametrized = returnType.isParameterized(); if( returnTypeParametrized == null ) assert returnTypeTypeParameters.length == 1; String returnTypeName = returnTypeTypeParameters[0].getParameterizedQualifiedSourceName(); w.print( params[p].getType().getParameterizedQualifiedSourceName() + " " + params[p].getName() ); if( p < params.length - 2 ) w.print( ", " );
String className = clazz.getSimpleSourceName(); int underscore = className.indexOf('_'); if (underscore >= 0) { Meaning meaning = method.getAnnotation(Meaning.class); if (meaning != null) { meaningString = meaning.value(); Key keyAnnot = method.getAnnotation(Key.class); if (keyAnnot != null) { key = keyAnnot.value(); ArgumentInfo argInfo = entry.addArgument(param.getName()); Optional optional = param.getAnnotation(Optional.class); if (optional != null) { argInfo.optional = true; PluralCount pluralCount = param.getAnnotation(PluralCount.class); if (pluralCount != null) { argInfo.isPluralCount = true; Example example = param.getAnnotation(Example.class); if (example != null) { argInfo.example = example.value(); Select select = param.getAnnotation(Select.class); if (select != null) { argInfo.isSelect = true;
protected Collection<Property> lookupJavaBeanPropertyAccessors(JClassType type) { Map<String, Property> properties = new HashMap<String, Property>(); JMethod[] methods = type.getOverridableMethods(); for (JMethod method : methods) { if (!method.isPublic() || method.isStatic()) { continue; if (method.getName().startsWith("set") && method.getParameters().length == 1) { if (parameters.length == 1) { JParameter parameter = parameters[0]; propertyType = parameter.getType().getErasedType().getQualifiedSourceName(); } else { logger.log(Type.WARN, "Property '" + name + "' has " + parameters.length + " parameters: " + parameters + "!"); continue; property.propertyType = propertyType; } else if (!property.propertyType.equals(propertyType)) { logger.log(Type.WARN, "Property '" + name + "' has an invalid setter: " + propertyType + " was excpected, " + property.propertyType + " found!"); continue; String propertyType = method.getReturnType().getErasedType().getQualifiedSourceName(); Property property = properties.get(name); if (property == null) {
for (JTypeParameter param : jmethod.getTypeParameters()) { typeParameterDeclaration.append(",").append(param.getQualifiedSourceName()); for (JParameter param : jmethod.getParameters()) { parameterArray.append(",").append(param.getName()); parameterDeclaration.append(",final ").append( param.getType().getParameterizedQualifiedSourceName()).append(" ").append( param.getName()); sw.println("public %s %s %s(%s) {", typeParameterDeclaration, jmethod.getReturnType() .getParameterizedQualifiedSourceName(), jmethod.getName(), parameterDeclaration); sw.indent(); .getParameters()[0].getName(), maybeReturn); PropertyName annotation = param.getAnnotation(PropertyName.class); String propertyName = annotation == null ? param.getName() : annotation.value(); boolean isContent = param.isAnnotationPresent(JsonRpcContent.class); if (isContent) { sw.println("x.getRequestData().setRequestContent(%s);", param.getName()); } else { sw.println("x.getRequestData().setNamedParameter(\"%s\", %s);", propertyName, param .getName());
JMethod[] methods = remoteService.getOverridableMethods(); JClassType rpcTokenClass = typeOracle.getType(RpcToken.class.getName()); RpcTokenImplementation tokenClassToUse = remoteService.findAnnotationInTypeHierarchy(RpcTokenImplementation.class); if (tokenClassToUse != null) { TreeLogger validationLogger = logger.branch(TreeLogger.DEBUG, "Analyzing methods:", null); JType returnType = method.getReturnType(); if (returnType != JPrimitiveType.VOID) { + returnType.getParameterizedQualifiedSourceName(), null); typesSentToBrowser.addRootType(returnTypeLogger, returnType); JParameter[] params = method.getParameters(); for (JParameter param : params) { JType paramType = param.getType(); typesSentFromBrowser.addRootType(paramLogger, paramType); JType[] exs = method.getThrows(); if (!exceptionClass.isAssignableFrom(ex.isClass())) { throwsLogger = throwsLogger.branch(TreeLogger.WARN, "'" + ex.getQualifiedSourceName() + "' is not a checked exception; only checked exceptions may be used", null);
private void writeCommandDefinition(TreeLogger logger, SourceWriter srcWriter, JMethod method, JParameter callbackParameter) throws UnableToCompleteException { srcWriter.print("CommandDefinition commandDefinition = new CommandDefinition("); srcWriter.print("\"%s\", ", this.serviceType.getQualifiedSourceName()); srcWriter.print("\"%s\", ", method.getName()); if (callbackParameter != null) { JParameterizedType parameterizedCallback = callbackParameter.getType().isParameterized(); if (parameterizedCallback != null) { srcWriter.print("\"%s\" ", parameterizedCallback.getTypeArgs()[0].getQualifiedSourceName()); } else { logger.branch(TreeLogger.ERROR, "Callback argument type for method " + method.getName() + " is not parametrized", null); throw new UnableToCompleteException(); } } else { srcWriter.print("\"%s\" ", method.getReturnType().getQualifiedSourceName()); } for (JParameter parameter : method.getParameters()) { if (!parameter.equals(callbackParameter)) { srcWriter.print(", \"%s\"", parameter.getType().getQualifiedSourceName()); } } srcWriter.println(");"); }
assert type.isInterface() == type : "Expecting interfaces only"; for (JMethod intfMethod : type.getOverridableMethods()) { assert intfMethod.isAbstract() : "Expecting only abstract methods"; JClassType implementingType = typeOracle.getSingleJsoImpl(intfMethod.getEnclosingType()); || implementingType.isAnnotationPresent(GwtScriptOnly.class)) { + intfMethod.getName(); mangledNames.add(mangledName); String decl = getBinaryOrPrimitiveName(intfMethod.getReturnType().getErasedType()) + " " + intfMethod.getName() + "("; for (JParameter param : intfMethod.getParameters()) { decl += ","; decl += getBinaryOrPrimitiveName(param.getType().getErasedType()); String returnName = getBinaryOrPrimitiveName(implementingMethod.getReturnType().getErasedType()); String jsoName = getBinaryOrPrimitiveName(implementingType); for (JParameter param : implementingMethod.getParameters()) { decl += ","; decl += getBinaryOrPrimitiveName(param.getType().getErasedType());
String boundMethod = method.getName(); if (method.isPrivate()) { logger.die("Method '%s' cannot be private.", boundMethod); JParameter[] parameters = method.getParameters(); if (parameters.length != 1) { logger.die( boundMethod); JClassType eventType = parameters[0].getType().isClass(); if (eventType == null) { logger.die("Parameter type is not a class."); logger.die( "Parameter '%s' is not an event (subclass of GwtEvent).", eventType.getName()); fieldWriter.getInstantiableType(), handlerType); logger.getTreeLogger().log(Type.INFO, "-------------"); logger.getTreeLogger().log(Type.INFO, "eventType = "+eventType); logger.getTreeLogger().log(Type.INFO, "DomEvent = "+oracle.findType(DomEvent.class.getCanonicalName())); logger.getTreeLogger().log(Type.INFO, "gwtEvent = "+oracle.findType(GwtEvent.class.getCanonicalName())); logger.getTreeLogger().log(Type.INFO, "to DomEvent ?"+eventType.isAssignableTo(oracle.findType(DomEvent.class.getCanonicalName()))); logger.getTreeLogger().log(Type.INFO, "to GwtEvent ?"+eventType.isAssignableTo(oracle.findType(GwtEvent.class.getCanonicalName()))); if (addHandlerMethodType == null) {
@Override public JClassType execute() throws UnableToCompleteException { for (JMethod method : callbackType.getOverridableMethods()) { getLogger().log(DEBUG, "checking method: " + method.getName()); if (method.getName().equals("onSuccess")) { JParameter[] parameters = method.getParameters(); getLogger().log(DEBUG, "checking method params: " + parameters.length); if (parameters.length == 2) { getLogger().log(DEBUG, "checking first param: " + parameters[0].getType()); if (parameters[0].getType() == METHOD_TYPE) { getLogger().log(DEBUG, "checking 2nd param: " + parameters[1].getType()); JType param2Type = parameters[1].getType(); JClassType type = param2Type.isClassOrInterface(); if (type == null) { getLogger().log(ERROR, "The type of the callback not supported: " + param2Type.getJNISignature()); throw new UnableToCompleteException(); } getLogger().log(DEBUG, "match: " + type); return type; } } } } getLogger().log(ERROR, "The type of the callback could not be determined: " + callbackType.getParameterizedQualifiedSourceName()); throw new UnableToCompleteException(); } });
private static JMethod getMethod(String methodName, String streamClassName, JClassType serializer, JClassType serializee) { JMethod[] overloads = serializer.getOverloads(methodName); for (JMethod overload : overloads) { JParameter[] parameters = overload.getParameters(); if (!parameters[0].getType().getQualifiedSourceName().equals(streamClassName)) { JType type = serializeeParam.getType(); if (type.isPrimitive() != null) { if (clazz.isAssignableFrom(serializee)) { if (isValidCustomFieldSerializerMethod(overload) && overload.getReturnType() == JPrimitiveType.VOID) { return overload;
protected String toStringExpression(JParameter arg) throws UnableToCompleteException { Attribute attribute = getAnnotation(arg, Attribute.class); if (attribute != null) { if (arg.getType().isClass().getField(attribute.value()) != null && arg.getType().isClass().getField(attribute.value()).isPublic()) { return "(" + arg.getName() + "." + attribute.value() + "+ \"\")"; } String publicGetter = "get" + attribute.value().substring(0, 1).toUpperCase() + attribute.value().substring(1); for (JMethod jMethod : arg.getType().isClass().getMethods()) { if (jMethod.getName().equals(publicGetter)) { return "(" + arg.getName() + "." + publicGetter + "()" + "+ \"\")"; } } getLogger().log(ERROR, "Neither public argument " + attribute.value() + " nor public getter " + publicGetter + " found!"); throw new UnableToCompleteException(); } return toStringExpression(arg.getType(), arg.getName()); }
private String genMethodPrototype( JMethod method ) { StringBuilder sb = new StringBuilder(); sb.append( "public " + method.getReturnType().getParameterizedQualifiedSourceName() + " " + method.getName() + "( " ); for( int i = 0; i < method.getParameters().length; i++ ) { JParameter param = method.getParameters()[i]; sb.append( param.getType().getParameterizedQualifiedSourceName() + " " + param.getName() ); if( i < method.getParameters().length - 1 ) sb.append( ", " ); } sb.append( " )" ); return sb.toString(); }
private JClassType findRenderParameterType(String resourceName) throws UnableToCompleteException { JMethod renderMethod = null; JClassType baseClass = writer.getBaseClass(); for (JMethod method : baseClass.getInheritableMethods()) { if (method.getName().equals("render")) { if (renderMethod == null) { renderMethod = method; } else { writer.die("%s declares more than one method named render", baseClass.getQualifiedSourceName()); } } } if (renderMethod == null) { return null; } JClassType matchingResourceType = null; for (JParameter jParameter : renderMethod.getParameters()) { if (jParameter.getName().equals(resourceName)) { matchingResourceType = jParameter.getType().isClassOrInterface(); break; } } return matchingResourceType; }
typesSentToBrowser = constructor.newInstance(logger, context); } catch (NoSuchMethodException ex) { logger.branch(TreeLogger.ERROR, "Unable to find a SerializableTypeOracleBuilder constructor", null); throw new UnableToCompleteException(); logger.branch(TreeLogger.ERROR, "Unable to invoke SerializableTypeOracleBuilder constructor", null); throw new UnableToCompleteException(); } catch (IllegalAccessException e) { logger.branch(TreeLogger.ERROR, "Unable to invoke SerializableTypeOracleBuilder constructor", null); throw new UnableToCompleteException(); } catch (IllegalArgumentException e) { JMethod[] methods = this.serviceType.getOverridableMethods(); TypeOracle typeOracle = context.getTypeOracle(); JType returnType = method.getReturnType(); if (returnType != JPrimitiveType.VOID) { typesSentToBrowser.addRootType(logger, returnType); JParameter[] params = method.getParameters(); for (JParameter param : params) { JType paramType = param.getType(); typesSentFromBrowser.addRootType(logger, paramType); JType[] exs = method.getThrows(); if (exs.length > 0) { for (JType ex : exs) {
public boolean format(TreeLogger logger, GwtLocale locale, StringGenerator out, Map<String, String> formatArgs, String subformat, String argName, JType argType, Parameters params) { if (!"java.util.Date".equals(argType.getQualifiedSourceName())) { logger.log(TreeLogger.ERROR, "Only java.util.Date acceptable for date format"); return true; int paramNum = params.getParameterIndex(tzArg.substring(1)); if (paramNum < 0) { logger.log(TreeLogger.ERROR, "Unable to resolve tz argument " + tzArg); return true; } else if (!"com.google.gwt.i18n.client.TimeZone".equals( params.getParameter(paramNum).getType().getQualifiedSourceName())) { logger.log(TreeLogger.ERROR, "Currency code parameter must be TimeZone"); return true; } else {