public RawMethod(final MethodReference baseMethod) {
VerifyArgument.notNull(baseMethod, "baseMethod");
final TypeReference declaringType = baseMethod.getDeclaringType();
_baseMethod = baseMethod;
_declaringType = MetadataHelper.eraseRecursive(declaringType);
_returnType = MetadataHelper.eraseRecursive(baseMethod.getReturnType());
_parameters = new ParameterDefinitionCollection(this);
for (final ParameterDefinition parameter : baseMethod.getParameters()) {
if (parameter.hasName()) {
_parameters.add(
new ParameterDefinition(
parameter.getSlot(),
parameter.getName(),
MetadataHelper.eraseRecursive(parameter.getParameterType())));
} else {
_parameters.add(
new ParameterDefinition(
parameter.getSlot(), MetadataHelper.eraseRecursive(parameter.getParameterType())));
}
}
_parameters.freeze();
}
public static PsiElement findArrayKeyValueInsideReference(
PsiElement psiElement, String methodReferenceName, String keyName) {
if (psiElement == null) {
return null;
}
Collection<MethodReference> tests =
PsiTreeUtil.findChildrenOfType(psiElement, MethodReference.class);
for (MethodReference methodReference : tests) {
// instance check
// methodReference.getSignature().equals("#M#C\\Symfony\\Component\\OptionsResolver\\OptionsResolverInterface.setDefaults")
if (PhpElementsUtil.isEqualMethodReferenceName(methodReference, methodReferenceName)) {
PsiElement[] parameters = methodReference.getParameters();
if (parameters.length > 0 && parameters[0] instanceof ArrayCreationExpression) {
PsiElement keyValue =
PhpElementsUtil.getArrayValue((ArrayCreationExpression) parameters[0], keyName);
if (keyValue != null) {
return keyValue;
}
}
}
}
return null;
}
@Override
public void generate(GeneratorContext context, SourceWriter writer, MethodReference methodRef)
throws IOException {
ClassReader cls = context.getClassSource().get(methodRef.getClassName());
MethodReader method = cls.getMethod(methodRef.getDescriptor());
AnnotationReader providerAnnot = method.getAnnotations().get(MetadataProvider.class.getName());
AnnotationReader refAnnot = method.getAnnotations().get(MetadataProviderRef.class.getName());
methodRef = MethodReference.parse(refAnnot.getValue("value").getString());
// Find and instantiate metadata generator
ValueType generatorType = providerAnnot.getValue("value").getJavaClass();
String generatorClassName = ((ValueType.Object) generatorType).getClassName();
Class<?> generatorClass;
try {
generatorClass = Class.forName(generatorClassName, true, context.getClassLoader());
} catch (ClassNotFoundException e) {
context
.getDiagnostics()
.error(
new CallLocation(methodRef),
"Can't find metadata provider class {{c0}}",
generatorClassName);
return;
}
Constructor<?> cons;
try {
cons = generatorClass.getConstructor();
} catch (NoSuchMethodException e) {
context
.getDiagnostics()
.error(
new CallLocation(methodRef),
"Metadata generator {{c0}} does not have " + "a public no-arg constructor",
generatorClassName);
return;
}
MetadataGenerator generator;
try {
generator = (MetadataGenerator) cons.newInstance();
} catch (IllegalAccessException | InstantiationException | InvocationTargetException e) {
context
.getDiagnostics()
.error(
new CallLocation(methodRef),
"Error instantiating metadata " + "generator {{c0}}",
generatorClassName);
return;
}
DefaultMetadataGeneratorContext metadataContext =
new DefaultMetadataGeneratorContext(
context.getClassSource(), context.getClassLoader(), context.getProperties(), context);
// Generate resource loader
Resource resource = generator.generateMetadata(metadataContext, methodRef);
writer.append("return ");
ResourceWriterHelper.write(writer, resource);
writer.append(';').softNewLine();
}
@Nullable
public static PsiElement getMethodParameterPsiElementAt(
@Nullable MethodReference methodReference, int index) {
if (methodReference == null) {
return null;
}
return getMethodParameterPsiElementAt(methodReference.getParameterList(), index);
}
/** Find the value for an annotation */
private Object getElementValue(String name, Class<?> valueType) {
for (AnnotationMember evp : elementValuePairs) {
String evpFieldName = evp.getName().toString();
if (name.equals(evpFieldName)) {
return evp.getValue();
}
}
MethodReference methRef =
MemberReference.findOrCreate(
type,
Atom.findOrCreateAsciiAtom(name),
Atom.findOrCreateAsciiAtom("()" + TypeReference.findOrCreate(valueType).getName()))
.asMethodReference();
try {
return methRef.resolve().getAnnotationDefault();
} catch (Throwable t) {
return NO_VALUE;
}
}
@Nullable
public static String getMethodParameterAt(@NotNull MethodReference methodReference, int index) {
ParameterList parameterList = methodReference.getParameterList();
if (parameterList == null) {
return null;
}
return getMethodParameterAt(parameterList, index);
}
private static void attachOnDefaultOptions(
Project project, HashMap<String, String> defaultValues, String typeClass) {
PsiElement setDefaultOptions =
PhpElementsUtil.getPsiElementsBySignatureSingle(
project, "#M#C\\" + typeClass + ".setDefaultOptions");
if (setDefaultOptions == null) {
return;
}
Collection<MethodReference> tests =
PsiTreeUtil.findChildrenOfType(setDefaultOptions, MethodReference.class);
for (MethodReference methodReference : tests) {
// instance check
// methodReference.getSignature().equals("#M#C\\Symfony\\Component\\OptionsResolver\\OptionsResolverInterface.setDefaults")
if (PhpElementsUtil.isEqualMethodReferenceName(methodReference, "setDefaults")) {
PsiElement[] parameters = methodReference.getParameters();
if (parameters.length > 0 && parameters[0] instanceof ArrayCreationExpression) {
for (String key :
PhpElementsUtil.getArrayCreationKeys((ArrayCreationExpression) parameters[0])) {
defaultValues.put(key, typeClass);
}
}
}
// support: parent::setDefaultOptions($resolver)
// Symfony\Component\Form\Extension\Core\Type\FormType:setDefaultOptions
if (PhpElementsUtil.isEqualMethodReferenceName(methodReference, "setDefaultOptions")
&& methodReference.getReferenceType() == PhpModifier.State.PARENT) {
PsiElement parentMethod =
PhpElementsUtil.getPsiElementsBySignatureSingle(
project, methodReference.getSignature());
if (parentMethod instanceof Method) {
PhpClass phpClass = ((Method) parentMethod).getContainingClass();
if (phpClass != null) {
attachOnDefaultOptions(project, defaultValues, phpClass.getPresentableFQN());
}
}
}
}
}
@Override
public void generate(GeneratorContext context, SourceWriter writer, MethodReference methodRef)
throws IOException {
switch (methodRef.getName()) {
case "toJavaScript":
generateToJavaScript(context, writer);
break;
case "fromJavaScript":
generateFromJavaScript(context, writer);
break;
}
}
@Nullable
public static PsiElement getArrayKeyValueInsideSignaturePsi(
Project project, String signature, String methodName, String keyName) {
PsiElement psiElement = PhpElementsUtil.getPsiElementsBySignatureSingle(project, signature);
if (psiElement == null) {
return null;
}
for (MethodReference methodReference :
PsiTreeUtil.findChildrenOfType(psiElement, MethodReference.class)) {
if (PhpElementsUtil.isEqualMethodReferenceName(methodReference, methodName)) {
PsiElement[] parameters = methodReference.getParameters();
if (parameters.length > 0 && parameters[0] instanceof ArrayCreationExpression) {
return PhpElementsUtil.getArrayValue((ArrayCreationExpression) parameters[0], keyName);
}
}
}
return null;
}
@Override
public GenericParameter findTypeVariable(final String name) {
for (final GenericParameter genericParameter : getGenericParameters()) {
if (StringUtilities.equals(genericParameter.getName(), name)) {
return genericParameter;
}
}
final MethodReference declaringMethod = getDeclaringMethod();
if (declaringMethod != null) {
return declaringMethod.findTypeVariable(name);
}
final TypeReference declaringType = getDeclaringType();
if (declaringType != null && !this.isStatic()) {
return declaringType.findTypeVariable(name);
}
return null;
}
/**
* Read the pair from the input stream and create object
*
* @param constantPool the constant pool for the class being read
* @param input stream to read from
* @param classLoader the class loader being used to load this annotation
* @return a newly created annotation member
*/
static AnnotationMember readAnnotationMember(
TypeReference type, int[] constantPool, DataInputStream input, ClassLoader classLoader)
throws IOException, ClassNotFoundException {
// Read name of pair
int elemNameIndex = input.readUnsignedShort();
Atom name = RVMClass.getUtf(constantPool, elemNameIndex);
MethodReference meth;
Object value;
if (type.isResolved()) {
meth = type.resolve().asClass().findDeclaredMethod(name).getMemberRef().asMethodReference();
value = RVMAnnotation.readValue(meth.getReturnType(), constantPool, input, classLoader);
} else {
value = RVMAnnotation.readValue(null, constantPool, input, classLoader);
meth =
MemberReference.findOrCreate(
type,
name,
Atom.findOrCreateAsciiAtom(
"()" + TypeReference.findOrCreate(value.getClass()).getName()))
.asMethodReference();
}
return new AnnotationMember(meth, value);
}
/**
* Create a method for reflectively invoking this method
*
* @param reflectionClass the class this method will belong to
* @param constantPool for the class
* @param memRef the member reference corresponding to this method
* @return the created method
*/
RVMMethod createReflectionMethod(
TypeReference reflectionClass, int[] constantPool, MethodReference memRef) {
TypeReference[] parameters = getParameterTypes();
int numParams = parameters.length;
byte[] bytecodes;
boolean interfaceCall = false;
int curBC = 0;
if (!isStatic()) {
if (!getDeclaringClass().isInterface()) {
// virtual call
bytecodes = new byte[8 * numParams + 8];
} else {
// interface call
bytecodes = new byte[8 * numParams + 10];
interfaceCall = true;
}
bytecodes[curBC] = JBC_aload_1;
curBC++;
} else {
// static call
bytecodes = new byte[8 * numParams + 7];
}
for (int i = 0; i < numParams; i++) {
if (parameters[i].isVoidType()) {
bytecodes[curBC] =
bytecodes[curBC + 1] =
bytecodes[curBC + 2] =
bytecodes[curBC + 3] =
bytecodes[curBC + 4] =
bytecodes[curBC + 5] =
bytecodes[curBC + 6] = bytecodes[curBC + 7] = (byte) JBC_nop;
continue;
}
bytecodes[curBC] = (byte) JBC_aload_2;
bytecodes[curBC + 1] = (byte) JBC_sipush;
bytecodes[curBC + 2] = (byte) (i >>> 8);
bytecodes[curBC + 3] = (byte) i;
bytecodes[curBC + 4] = (byte) JBC_aaload;
if (!parameters[i].isPrimitiveType()) {
bytecodes[curBC + 5] = (byte) JBC_checkcast;
if (VM.VerifyAssertions) VM._assert(parameters[i].getId() != 0);
constantPool[i + 1] = ClassFileReader.packCPEntry(CP_CLASS, parameters[i].getId());
bytecodes[curBC + 6] = (byte) ((i + 1) >>> 8);
bytecodes[curBC + 7] = (byte) (i + 1);
} else if (parameters[i].isWordLikeType()) {
bytecodes[curBC + 5] = bytecodes[curBC + 6] = bytecodes[curBC + 7] = (byte) JBC_nop;
} else {
bytecodes[curBC + 5] = (byte) JBC_invokestatic;
MemberReference unboxMethod;
if (parameters[i].isBooleanType()) {
unboxMethod =
MethodReference.findOrCreate(
baseReflectionClass,
Atom.findOrCreateUnicodeAtom("unboxAsBoolean"),
Atom.findOrCreateUnicodeAtom("(Ljava/lang/Object;)Z"));
} else if (parameters[i].isByteType()) {
unboxMethod =
MethodReference.findOrCreate(
baseReflectionClass,
Atom.findOrCreateUnicodeAtom("unboxAsByte"),
Atom.findOrCreateUnicodeAtom("(Ljava/lang/Object;)B"));
} else if (parameters[i].isShortType()) {
unboxMethod =
MethodReference.findOrCreate(
baseReflectionClass,
Atom.findOrCreateUnicodeAtom("unboxAsShort"),
Atom.findOrCreateUnicodeAtom("(Ljava/lang/Object;)S"));
} else if (parameters[i].isCharType()) {
unboxMethod =
MethodReference.findOrCreate(
baseReflectionClass,
Atom.findOrCreateUnicodeAtom("unboxAsChar"),
Atom.findOrCreateUnicodeAtom("(Ljava/lang/Object;)C"));
} else if (parameters[i].isIntType()) {
unboxMethod =
MethodReference.findOrCreate(
baseReflectionClass,
Atom.findOrCreateUnicodeAtom("unboxAsInt"),
Atom.findOrCreateUnicodeAtom("(Ljava/lang/Object;)I"));
} else if (parameters[i].isLongType()) {
unboxMethod =
MethodReference.findOrCreate(
baseReflectionClass,
Atom.findOrCreateUnicodeAtom("unboxAsLong"),
Atom.findOrCreateUnicodeAtom("(Ljava/lang/Object;)J"));
} else if (parameters[i].isFloatType()) {
unboxMethod =
MethodReference.findOrCreate(
baseReflectionClass,
Atom.findOrCreateUnicodeAtom("unboxAsFloat"),
Atom.findOrCreateUnicodeAtom("(Ljava/lang/Object;)F"));
} else {
if (VM.VerifyAssertions) VM._assert(parameters[i].isDoubleType());
unboxMethod =
MethodReference.findOrCreate(
baseReflectionClass,
Atom.findOrCreateUnicodeAtom("unboxAsDouble"),
Atom.findOrCreateUnicodeAtom("(Ljava/lang/Object;)D"));
}
constantPool[i + 1] = ClassFileReader.packCPEntry(CP_MEMBER, unboxMethod.getId());
bytecodes[curBC + 6] = (byte) ((i + 1) >>> 8);
bytecodes[curBC + 7] = (byte) (i + 1);
}
curBC += 8;
}
if (isStatic()) {
bytecodes[curBC] = (byte) JBC_invokestatic;
} else if (isObjectInitializer() || isPrivate()) {
bytecodes[curBC] = (byte) JBC_invokespecial;
} else if (interfaceCall) {
bytecodes[curBC] = (byte) JBC_invokeinterface;
} else {
bytecodes[curBC] = (byte) JBC_invokevirtual;
}
constantPool[numParams + 1] = ClassFileReader.packCPEntry(CP_MEMBER, getId());
bytecodes[curBC + 1] = (byte) ((numParams + 1) >>> 8);
bytecodes[curBC + 2] = (byte) (numParams + 1);
if (interfaceCall) {
// invokeinterface bytecodes are historically longer than others
curBC += 2;
}
TypeReference returnType = getReturnType();
if (!returnType.isPrimitiveType() || returnType.isWordLikeType()) {
bytecodes[curBC + 3] = (byte) JBC_nop;
bytecodes[curBC + 4] = (byte) JBC_nop;
bytecodes[curBC + 5] = (byte) JBC_nop;
} else if (returnType.isVoidType()) {
bytecodes[curBC + 3] = (byte) JBC_aconst_null;
bytecodes[curBC + 4] = (byte) JBC_nop;
bytecodes[curBC + 5] = (byte) JBC_nop;
} else {
MemberReference boxMethod;
if (returnType.isBooleanType()) {
boxMethod =
MethodReference.findOrCreate(
baseReflectionClass,
Atom.findOrCreateUnicodeAtom("boxAsBoolean"),
Atom.findOrCreateUnicodeAtom("(Z)Ljava/lang/Object;"));
} else if (returnType.isByteType()) {
boxMethod =
MethodReference.findOrCreate(
baseReflectionClass,
Atom.findOrCreateUnicodeAtom("boxAsByte"),
Atom.findOrCreateUnicodeAtom("(B)Ljava/lang/Object;"));
} else if (returnType.isShortType()) {
boxMethod =
MethodReference.findOrCreate(
baseReflectionClass,
Atom.findOrCreateUnicodeAtom("boxAsShort"),
Atom.findOrCreateUnicodeAtom("(S)Ljava/lang/Object;"));
} else if (returnType.isCharType()) {
boxMethod =
MethodReference.findOrCreate(
baseReflectionClass,
Atom.findOrCreateUnicodeAtom("boxAsChar"),
Atom.findOrCreateUnicodeAtom("(C)Ljava/lang/Object;"));
} else if (returnType.isIntType()) {
boxMethod =
MethodReference.findOrCreate(
baseReflectionClass,
Atom.findOrCreateUnicodeAtom("boxAsInt"),
Atom.findOrCreateUnicodeAtom("(I)Ljava/lang/Object;"));
} else if (returnType.isLongType()) {
boxMethod =
MethodReference.findOrCreate(
baseReflectionClass,
Atom.findOrCreateUnicodeAtom("boxAsLong"),
Atom.findOrCreateUnicodeAtom("(J)Ljava/lang/Object;"));
} else if (returnType.isFloatType()) {
boxMethod =
MethodReference.findOrCreate(
baseReflectionClass,
Atom.findOrCreateUnicodeAtom("boxAsFloat"),
Atom.findOrCreateUnicodeAtom("(F)Ljava/lang/Object;"));
} else {
if (VM.VerifyAssertions) VM._assert(returnType.isDoubleType());
boxMethod =
MethodReference.findOrCreate(
baseReflectionClass,
Atom.findOrCreateUnicodeAtom("boxAsDouble"),
Atom.findOrCreateUnicodeAtom("(D)Ljava/lang/Object;"));
}
constantPool[numParams + 2] = ClassFileReader.packCPEntry(CP_MEMBER, boxMethod.getId());
bytecodes[curBC + 3] = (byte) JBC_invokestatic;
bytecodes[curBC + 4] = (byte) ((numParams + 2) >>> 8);
bytecodes[curBC + 5] = (byte) (numParams + 2);
}
bytecodes[curBC + 6] = (byte) JBC_areturn;
return new NormalMethod(
reflectionClass,
memRef,
(short) (ACC_PUBLIC | ACC_FINAL | ACC_SYNTHETIC),
null,
(short) 3,
(short) (getParameterWords() + 2),
bytecodes,
null,
null,
null,
constantPool,
null,
null,
null,
null);
}
/** Compute hashCode from meth */
public int hashCode() {
return meth.hashCode();
}
/** @return the name of the of the given pair */
Atom getName() {
return meth.getName();
}
private List<Instruction> transformInvoke(InvokeInstruction insn) {
if (insn.getType() != InvocationType.VIRTUAL) {
return null;
}
MethodReference method = insn.getMethod();
if (method.getClassName().equals(ResourceArray.class.getName())
|| method.getClassName().equals(ResourceMap.class.getName())) {
if (method.getName().equals("keys")) {
return transformKeys(insn);
}
InvokeInstruction accessInsn = new InvokeInstruction();
accessInsn.setType(InvocationType.SPECIAL);
ValueType[] types = new ValueType[method.getDescriptor().parameterCount() + 2];
types[0] = ValueType.object("java.lang.Object");
System.arraycopy(
method.getDescriptor().getSignature(),
0,
types,
1,
method.getDescriptor().parameterCount() + 1);
accessInsn.setMethod(
new MethodReference(ResourceAccessor.class.getName(), method.getName(), types));
accessInsn.getArguments().add(insn.getInstance());
accessInsn.getArguments().addAll(insn.getArguments());
accessInsn.setReceiver(insn.getReceiver());
return Arrays.asList(accessInsn);
}
ClassReader iface = innerSource.get(method.getClassName());
if (iface == null
|| !innerSource.isSuperType(Resource.class.getName(), iface.getName()).orElse(false)) {
return null;
}
if (method.getName().startsWith("get")) {
if (method.getName().length() > 3) {
return transformGetterInvocation(insn, getPropertyName(method.getName().substring(3)));
}
} else if (method.getName().startsWith("is")) {
if (method.getName().length() > 2) {
return transformGetterInvocation(insn, getPropertyName(method.getName().substring(2)));
}
} else if (method.getName().startsWith("set")) {
if (method.getName().length() > 3) {
return transformSetterInvocation(insn, getPropertyName(method.getName().substring(3)));
}
}
return null;
}
@Override
public final String getName() {
return _baseMethod.getName();
}
@NotNull
public static PsiElement createCompilerPass(
@NotNull PhpClass bundleClass, @NotNull String className) throws Exception {
VirtualFile directory =
bundleClass.getContainingFile().getContainingDirectory().getVirtualFile();
if (fileExists(directory, className)) {
throw new Exception("File already exists");
}
PhpPsiElement scopeForUseOperator = PhpCodeInsightUtil.findScopeForUseOperator(bundleClass);
if (scopeForUseOperator == null) {
throw new Exception("No 'use' scope found");
}
VirtualFile compilerDirectory = getAndCreateCompilerDirectory(directory);
if (compilerDirectory == null) {
throw new Exception("Directory creation failed");
}
Project project = bundleClass.getProject();
if (bundleClass.findOwnMethodByName("build") == null) {
insertUseIfNecessary(
scopeForUseOperator, "\\Symfony\\Component\\DependencyInjection\\ContainerBuilder");
Method method =
PhpPsiElementFactory.createMethod(
project,
""
+ "public function build(ContainerBuilder $container)\n"
+ " {\n"
+ " parent::build($container);\n"
+ " }");
PhpCodeEditUtil.insertClassMember(bundleClass, method);
}
Method buildMethod = bundleClass.findOwnMethodByName("build");
if (buildMethod == null) {
throw new Exception("No 'build' method found");
}
String relativePath = VfsUtil.getRelativePath(compilerDirectory, directory);
if (relativePath == null) {
throw new Exception("path error");
}
MethodReference methodReference =
PhpPsiElementFactory.createMethodReference(
project, "$container->addCompilerPass(new " + className + "());");
String ns = bundleClass.getNamespaceName() + relativePath.replace("/", "\\");
String nsClass = ns + "\\" + className;
insertUseIfNecessary(scopeForUseOperator, nsClass);
GroupStatement groupStatement =
PhpPsiUtil.getChildByCondition(buildMethod, GroupStatement.INSTANCEOF);
if (groupStatement != null) {
PsiElement semicolon = methodReference.getNextSibling();
groupStatement.addRangeBefore(methodReference, semicolon, groupStatement.getLastChild());
}
String COMPILER_TEMPLATE = "/resources/fileTemplates/compiler_pass.php";
String fileTemplateContent = getFileTemplateContent(COMPILER_TEMPLATE);
if (fileTemplateContent == null) {
throw new Exception("Template content error");
}
String replace =
fileTemplateContent
.replace("{{ ns }}", ns.startsWith("\\") ? ns.substring(1) : ns)
.replace("{{ class }}", className);
PsiFile fileFromText =
PsiFileFactory.getInstance(project)
.createFileFromText(className + ".php", PhpFileType.INSTANCE, replace);
CodeStyleManager.getInstance(project).reformat(fileFromText);
return PsiDirectoryFactory.getInstance(project)
.createDirectory(compilerDirectory)
.add(fileFromText);
}
public static MethodHandle constructorCaller(MethodReference method) {
return constructorCaller(method.getClassName(), method.getDescriptor());
}
public static MethodHandle interfaceCaller(MethodReference method) {
return interfaceCaller(method.getClassName(), method.getDescriptor());
}
public static MethodHandle specialCaller(MethodReference method) {
return specialCaller(method.getClassName(), method.getDescriptor());
}
@Override
public MethodDefinition resolve() {
return _baseMethod.resolve();
}
private Map<String, String> findRootDefinition(Collection<MethodReference> methodReferences) {
Map<String, String> roots = new HashMap<String, String>();
if (methodReferences.size() == 0) {
return roots;
}
String rootAlias = null;
String repository = null;
for (MethodReference methodReference : methodReferences) {
String methodReferenceName = methodReference.getName();
// get alias
// ->createQueryBuilder('test');
if ("createQueryBuilder".equals(methodReferenceName)) {
String possibleAlias =
PhpElementsUtil.getStringValue(
PsiElementUtils.getMethodParameterPsiElementAt(methodReference, 0));
if (possibleAlias != null) {
rootAlias = possibleAlias;
}
}
// find repository class
// getRepository('Foo')->createQueryBuilder('test');
if ("getRepository".equals(methodReferenceName)) {
String possibleRepository =
PhpElementsUtil.getStringValue(
PsiElementUtils.getMethodParameterPsiElementAt(methodReference, 0));
if (possibleRepository != null) {
repository = possibleRepository;
PhpClass phpClass = EntityHelper.resolveShortcutName(project, repository);
if (phpClass != null) {
repository = phpClass.getPresentableFQN();
}
}
}
// $qb->from('Foo\Class', 'article')
if ("from".equals(methodReferenceName)) {
String table =
PhpElementsUtil.getStringValue(
PsiElementUtils.getMethodParameterPsiElementAt(methodReference, 0));
String alias =
PhpElementsUtil.getStringValue(
PsiElementUtils.getMethodParameterPsiElementAt(methodReference, 1));
if (table != null && alias != null) {
PhpClass phpClass = EntityHelper.resolveShortcutName(project, table);
if (phpClass != null) {
table = phpClass.getPresentableFQN();
}
roots.put(table, alias);
}
}
}
// we have a valid root so add it
if (rootAlias != null && repository != null) {
roots.put(repository, rootAlias);
}
// we found a alias but not a repository name, so try a scope search if we are inside repository
// class
// class implements \Doctrine\Common\Persistence\ObjectRepository, so search for model name of
// "repositoryClass"
if (rootAlias != null && repository == null) {
MethodReference methodReference = methodReferences.iterator().next();
PhpClass phpClass = PsiTreeUtil.getParentOfType(methodReference, PhpClass.class);
if (new Symfony2InterfacesUtil()
.isInstanceOf(phpClass, "\\Doctrine\\Common\\Persistence\\ObjectRepository")) {
for (DoctrineModel model : EntityHelper.getModelClasses(project)) {
String className = model.getPhpClass().getPresentableFQN();
if (className != null) {
PhpClass resolvedRepoName = EntityHelper.getEntityRepositoryClass(project, className);
if (PhpElementsUtil.isEqualClassName(resolvedRepoName, phpClass.getPresentableFQN())) {
roots.put(className, rootAlias);
return roots;
}
}
}
}
}
// search on PhpTypeProvider
// $er->createQueryBuilder()
if (rootAlias != null && repository == null) {
for (MethodReference methodReference : methodReferences) {
if ("createQueryBuilder".equals(methodReference.getName())) {
String signature = methodReference.getSignature();
int endIndex = signature.lastIndexOf(ObjectRepositoryTypeProvider.TRIM_KEY);
if (endIndex != -1) {
String parameter = signature.substring(endIndex + 1);
int point = parameter.indexOf(".");
if (point > -1) {
parameter = parameter.substring(0, point);
parameter =
PhpTypeProviderUtil.getResolvedParameter(
PhpIndex.getInstance(project), parameter);
if (parameter != null) {
PhpClass phpClass = EntityHelper.resolveShortcutName(project, parameter);
if (phpClass != null && phpClass.getPresentableFQN() != null) {
roots.put(phpClass.getPresentableFQN(), rootAlias);
return roots;
}
}
}
}
}
}
}
return roots;
}
public static boolean isEqualMethodReferenceName(
MethodReference methodReference, String methodName) {
String name = methodReference.getName();
return name != null && name.equals(methodName);
}
public QueryBuilderScopeContext collect() {
QueryBuilderScopeContext qb = new QueryBuilderScopeContext();
// doctrine needs valid root with an alias, try to find one in method references or scope
Map<String, String> map = this.findRootDefinition(methodReferences);
if (map.size() > 0) {
Map.Entry<String, String> entry = map.entrySet().iterator().next();
qb.addTable(entry.getKey(), entry.getValue());
}
for (MethodReference methodReference : methodReferences) {
String name = methodReference.getName();
if (name != null) {
collectParameter(qb, methodReference, name);
collectJoins(qb, methodReference, name);
collectSelects(qb, methodReference, name);
collectSelectInForm(qb, methodReference, name);
}
}
// first tableMap entry is root, we add several initial data
if (qb.getTableMap().size() > 0) {
Map.Entry<String, String> entry = qb.getTableMap().entrySet().iterator().next();
String className = entry.getKey();
PhpClass phpClass = PhpElementsUtil.getClassInterface(project, className);
// add root select fields
if (phpClass != null) {
qb.addPropertyAlias(
entry.getValue(),
new QueryBuilderPropertyAlias(
entry.getValue(),
null,
new DoctrineModelField(entry.getValue())
.addTarget(phpClass)
.setTypeName(phpClass.getPresentableFQN())));
List<QueryBuilderRelation> relationList = new ArrayList<QueryBuilderRelation>();
// qb.addRelation(entry.getValue(), attachRelationFields(phpClass));
for (DoctrineModelField field : EntityHelper.getModelFields(phpClass)) {
qb.addPropertyAlias(
entry.getValue() + "." + field.getName(),
new QueryBuilderPropertyAlias(entry.getValue(), field.getName(), field));
if (field.getRelation() != null && field.getRelationType() != null) {
relationList.add(new QueryBuilderRelation(field.getName(), field.getRelation()));
}
}
qb.addRelation(entry.getValue(), relationList);
}
QueryBuilderRelationClassResolver resolver =
new QueryBuilderRelationClassResolver(
project, entry.getValue(), entry.getKey(), qb.getRelationMap(), qb.getJoinMap());
resolver.collect();
}
// we have a querybuilder which complete known elements now
// se we can builder a property (field) map table from it
this.buildPropertyMap(qb);
return qb;
}
