| /* |
| * Copyright 2019 Google Inc. All Rights Reserved. |
| * |
| * 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.turbine.processing; |
| |
| import static java.util.Objects.requireNonNull; |
| |
| import com.google.common.base.Joiner; |
| import com.google.common.base.Splitter; |
| import com.google.common.base.Supplier; |
| import com.google.common.collect.ImmutableList; |
| import com.google.common.collect.ImmutableSet; |
| import com.google.common.collect.Iterables; |
| import com.google.common.collect.Sets; |
| import com.google.turbine.binder.bound.AnnotationMetadata; |
| import com.google.turbine.binder.bound.SourceTypeBoundClass; |
| import com.google.turbine.binder.bound.TurbineAnnotationValue; |
| import com.google.turbine.binder.bound.TypeBoundClass; |
| import com.google.turbine.binder.bound.TypeBoundClass.FieldInfo; |
| import com.google.turbine.binder.bound.TypeBoundClass.MethodInfo; |
| import com.google.turbine.binder.bound.TypeBoundClass.ParamInfo; |
| import com.google.turbine.binder.bound.TypeBoundClass.TyVarInfo; |
| import com.google.turbine.binder.lookup.PackageScope; |
| import com.google.turbine.binder.sym.ClassSymbol; |
| import com.google.turbine.binder.sym.FieldSymbol; |
| import com.google.turbine.binder.sym.MethodSymbol; |
| import com.google.turbine.binder.sym.PackageSymbol; |
| import com.google.turbine.binder.sym.ParamSymbol; |
| import com.google.turbine.binder.sym.Symbol; |
| import com.google.turbine.binder.sym.TyVarSymbol; |
| import com.google.turbine.diag.TurbineError; |
| import com.google.turbine.diag.TurbineError.ErrorKind; |
| import com.google.turbine.model.Const; |
| import com.google.turbine.model.Const.ArrayInitValue; |
| import com.google.turbine.model.TurbineFlag; |
| import com.google.turbine.tree.Tree; |
| import com.google.turbine.tree.Tree.MethDecl; |
| import com.google.turbine.tree.Tree.TyDecl; |
| import com.google.turbine.tree.Tree.VarDecl; |
| import com.google.turbine.type.AnnoInfo; |
| import com.google.turbine.type.Type; |
| import com.google.turbine.type.Type.ClassTy; |
| import com.google.turbine.type.Type.ClassTy.SimpleClassTy; |
| import com.google.turbine.type.Type.ErrorTy; |
| import java.lang.annotation.Annotation; |
| import java.util.ArrayDeque; |
| import java.util.ArrayList; |
| import java.util.Deque; |
| import java.util.EnumSet; |
| import java.util.LinkedHashMap; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Objects; |
| import java.util.Set; |
| import javax.lang.model.element.AnnotationMirror; |
| import javax.lang.model.element.AnnotationValue; |
| import javax.lang.model.element.Element; |
| import javax.lang.model.element.ElementKind; |
| import javax.lang.model.element.ElementVisitor; |
| import javax.lang.model.element.ExecutableElement; |
| import javax.lang.model.element.Modifier; |
| import javax.lang.model.element.Name; |
| import javax.lang.model.element.NestingKind; |
| import javax.lang.model.element.PackageElement; |
| import javax.lang.model.element.TypeElement; |
| import javax.lang.model.element.TypeParameterElement; |
| import javax.lang.model.element.VariableElement; |
| import javax.lang.model.type.TypeMirror; |
| import org.checkerframework.checker.nullness.qual.Nullable; |
| |
| /** An {@link Element} implementation backed by a {@link Symbol}. */ |
| public abstract class TurbineElement implements Element { |
| |
| public abstract Symbol sym(); |
| |
| public abstract String javadoc(); |
| |
| @Override |
| public abstract int hashCode(); |
| |
| @Override |
| public abstract boolean equals(@Nullable Object obj); |
| |
| protected final ModelFactory factory; |
| private final Supplier<ImmutableList<AnnotationMirror>> annotationMirrors; |
| |
| protected <T> Supplier<T> memoize(Supplier<T> supplier) { |
| return factory.memoize(supplier); |
| } |
| |
| protected TurbineElement(ModelFactory factory) { |
| this.factory = requireNonNull(factory); |
| this.annotationMirrors = |
| factory.memoize( |
| new Supplier<ImmutableList<AnnotationMirror>>() { |
| @Override |
| public ImmutableList<AnnotationMirror> get() { |
| ImmutableList.Builder<AnnotationMirror> result = ImmutableList.builder(); |
| for (AnnoInfo anno : annos()) { |
| result.add(TurbineAnnotationMirror.create(factory, anno)); |
| } |
| return result.build(); |
| } |
| }); |
| } |
| |
| static AnnoInfo getAnnotation(Iterable<AnnoInfo> annos, ClassSymbol sym) { |
| for (AnnoInfo anno : annos) { |
| if (Objects.equals(anno.sym(), sym)) { |
| return anno; |
| } |
| } |
| return null; |
| } |
| |
| @Override |
| public <A extends Annotation> A getAnnotation(Class<A> annotationType) { |
| ClassSymbol sym = new ClassSymbol(annotationType.getName().replace('.', '/')); |
| TypeBoundClass info = factory.getSymbol(sym); |
| if (info == null) { |
| return null; |
| } |
| AnnoInfo anno = getAnnotation(annos(), sym); |
| if (anno == null) { |
| return null; |
| } |
| return TurbineAnnotationProxy.create(factory, annotationType, anno); |
| } |
| |
| @Override |
| public final <A extends Annotation> A[] getAnnotationsByType(Class<A> annotationType) { |
| ClassSymbol sym = new ClassSymbol(annotationType.getName().replace('.', '/')); |
| TypeBoundClass info = factory.getSymbol(sym); |
| if (info == null) { |
| return null; |
| } |
| AnnotationMetadata metadata = info.annotationMetadata(); |
| if (metadata == null) { |
| return null; |
| } |
| List<A> result = new ArrayList<>(); |
| for (AnnoInfo anno : annos()) { |
| if (anno.sym().equals(sym)) { |
| result.add(TurbineAnnotationProxy.create(factory, annotationType, anno)); |
| continue; |
| } |
| if (anno.sym().equals(metadata.repeatable())) { |
| // requireNonNull is safe because java.lang.annotation.Repeatable declares `value`. |
| ArrayInitValue arrayValue = (ArrayInitValue) requireNonNull(anno.values().get("value")); |
| for (Const element : arrayValue.elements()) { |
| result.add( |
| TurbineAnnotationProxy.create( |
| factory, annotationType, ((TurbineAnnotationValue) element).info())); |
| } |
| } |
| } |
| return Iterables.toArray(result, annotationType); |
| } |
| |
| @Override |
| public final List<? extends AnnotationMirror> getAnnotationMirrors() { |
| return annotationMirrors.get(); |
| } |
| |
| List<? extends AnnotationMirror> getAllAnnotationMirrors() { |
| return getAnnotationMirrors(); |
| } |
| |
| protected abstract ImmutableList<AnnoInfo> annos(); |
| |
| /** A {@link TypeElement} implementation backed by a {@link ClassSymbol}. */ |
| static class TurbineTypeElement extends TurbineElement implements TypeElement { |
| |
| @Override |
| public int hashCode() { |
| return sym.hashCode(); |
| } |
| |
| private final ClassSymbol sym; |
| private final Supplier<TypeBoundClass> info; |
| |
| TurbineTypeElement(ModelFactory factory, ClassSymbol sym) { |
| super(factory); |
| this.sym = requireNonNull(sym); |
| this.info = |
| memoize( |
| new Supplier<TypeBoundClass>() { |
| @Override |
| public TypeBoundClass get() { |
| return factory.getSymbol(sym); |
| } |
| }); |
| } |
| |
| @Nullable |
| TypeBoundClass info() { |
| return info.get(); |
| } |
| |
| TypeBoundClass infoNonNull() { |
| TypeBoundClass info = info(); |
| if (info == null) { |
| throw TurbineError.format(/* source= */ null, ErrorKind.SYMBOL_NOT_FOUND, sym); |
| } |
| return info; |
| } |
| |
| @Override |
| public NestingKind getNestingKind() { |
| TypeBoundClass info = info(); |
| return (info != null && info.owner() != null) ? NestingKind.MEMBER : NestingKind.TOP_LEVEL; |
| } |
| |
| private final Supplier<TurbineName> qualifiedName = |
| memoize( |
| new Supplier<TurbineName>() { |
| @Override |
| public TurbineName get() { |
| TypeBoundClass info = info(); |
| if (info == null || info.owner() == null) { |
| return new TurbineName(sym.toString()); |
| } |
| ClassSymbol sym = sym(); |
| Deque<String> flat = new ArrayDeque<>(); |
| while (info.owner() != null) { |
| flat.addFirst(sym.binaryName().substring(info.owner().binaryName().length() + 1)); |
| sym = info.owner(); |
| info = factory.getSymbol(sym); |
| } |
| flat.addFirst(sym.toString()); |
| return new TurbineName(Joiner.on('.').join(flat)); |
| } |
| }); |
| |
| @Override |
| public Name getQualifiedName() { |
| return qualifiedName.get(); |
| } |
| |
| private final Supplier<TypeMirror> superclass = |
| memoize( |
| new Supplier<TypeMirror>() { |
| @Override |
| public TypeMirror get() { |
| TypeBoundClass info = infoNonNull(); |
| switch (info.kind()) { |
| case CLASS: |
| case ENUM: |
| if (info.superclass() != null) { |
| return factory.asTypeMirror(info.superClassType()); |
| } |
| if (info instanceof SourceTypeBoundClass) { |
| // support simple names for stuff that doesn't exist |
| TyDecl decl = ((SourceTypeBoundClass) info).decl(); |
| if (decl.xtnds().isPresent()) { |
| ArrayDeque<Tree.Ident> flat = new ArrayDeque<>(); |
| for (Tree.ClassTy curr = decl.xtnds().get(); |
| curr != null; |
| curr = curr.base().orElse(null)) { |
| flat.addFirst(curr.name()); |
| } |
| return factory.asTypeMirror(ErrorTy.create(flat)); |
| } |
| } |
| return factory.noType(); |
| case INTERFACE: |
| case ANNOTATION: |
| return factory.noType(); |
| } |
| throw new AssertionError(info.kind()); |
| } |
| }); |
| |
| @Override |
| public TypeMirror getSuperclass() { |
| return superclass.get(); |
| } |
| |
| @Override |
| public String toString() { |
| return getQualifiedName().toString(); |
| } |
| |
| private final Supplier<List<TypeMirror>> interfaces = |
| memoize( |
| new Supplier<List<TypeMirror>>() { |
| @Override |
| public List<TypeMirror> get() { |
| return factory.asTypeMirrors(infoNonNull().interfaceTypes()); |
| } |
| }); |
| |
| @Override |
| public List<? extends TypeMirror> getInterfaces() { |
| return interfaces.get(); |
| } |
| |
| private final Supplier<ImmutableList<TypeParameterElement>> typeParameters = |
| memoize( |
| new Supplier<ImmutableList<TypeParameterElement>>() { |
| @Override |
| public ImmutableList<TypeParameterElement> get() { |
| ImmutableList.Builder<TypeParameterElement> result = ImmutableList.builder(); |
| for (TyVarSymbol p : infoNonNull().typeParameters().values()) { |
| result.add(factory.typeParameterElement(p)); |
| } |
| return result.build(); |
| } |
| }); |
| |
| @Override |
| public List<? extends TypeParameterElement> getTypeParameters() { |
| return typeParameters.get(); |
| } |
| |
| private final Supplier<TypeMirror> type = |
| memoize( |
| new Supplier<TypeMirror>() { |
| @Override |
| public TypeMirror get() { |
| return factory.asTypeMirror(asGenericType(sym)); |
| } |
| |
| ClassTy asGenericType(ClassSymbol symbol) { |
| TypeBoundClass info = info(); |
| if (info == null) { |
| return ClassTy.asNonParametricClassTy(symbol); |
| } |
| Deque<Type.ClassTy.SimpleClassTy> simples = new ArrayDeque<>(); |
| simples.addFirst(simple(symbol, info)); |
| while (info.owner() != null && (info.access() & TurbineFlag.ACC_STATIC) == 0) { |
| symbol = info.owner(); |
| info = factory.getSymbol(symbol); |
| simples.addFirst(simple(symbol, info)); |
| } |
| return ClassTy.create(ImmutableList.copyOf(simples)); |
| } |
| |
| private SimpleClassTy simple(ClassSymbol sym, TypeBoundClass info) { |
| ImmutableList.Builder<Type> args = ImmutableList.builder(); |
| for (TyVarSymbol t : info.typeParameters().values()) { |
| args.add(Type.TyVar.create(t, ImmutableList.of())); |
| } |
| return SimpleClassTy.create(sym, args.build(), ImmutableList.of()); |
| } |
| }); |
| |
| @Override |
| public TypeMirror asType() { |
| return type.get(); |
| } |
| |
| @Override |
| public ElementKind getKind() { |
| TypeBoundClass info = infoNonNull(); |
| switch (info.kind()) { |
| case CLASS: |
| return ElementKind.CLASS; |
| case INTERFACE: |
| return ElementKind.INTERFACE; |
| case ENUM: |
| return ElementKind.ENUM; |
| case ANNOTATION: |
| return ElementKind.ANNOTATION_TYPE; |
| } |
| throw new AssertionError(info.kind()); |
| } |
| |
| @Override |
| public Set<Modifier> getModifiers() { |
| return asModifierSet(ModifierOwner.TYPE, infoNonNull().access() & ~TurbineFlag.ACC_SUPER); |
| } |
| |
| private final Supplier<TurbineName> simpleName = |
| memoize( |
| new Supplier<TurbineName>() { |
| @Override |
| public TurbineName get() { |
| TypeBoundClass info = info(); |
| if (info == null || info.owner() == null) { |
| return new TurbineName(sym.simpleName()); |
| } |
| return new TurbineName( |
| sym.binaryName().substring(info.owner().binaryName().length() + 1)); |
| } |
| }); |
| |
| @Override |
| public Name getSimpleName() { |
| return simpleName.get(); |
| } |
| |
| private final Supplier<Element> enclosing = |
| memoize( |
| new Supplier<Element>() { |
| @Override |
| public Element get() { |
| return getNestingKind().equals(NestingKind.TOP_LEVEL) |
| ? factory.packageElement(sym.owner()) |
| : factory.typeElement(info().owner()); |
| } |
| }); |
| |
| @Override |
| public Element getEnclosingElement() { |
| return enclosing.get(); |
| } |
| |
| private final Supplier<ImmutableList<Element>> enclosed = |
| memoize( |
| new Supplier<ImmutableList<Element>>() { |
| @Override |
| public ImmutableList<Element> get() { |
| TypeBoundClass info = infoNonNull(); |
| ImmutableList.Builder<Element> result = ImmutableList.builder(); |
| for (FieldInfo field : info.fields()) { |
| result.add(factory.fieldElement(field.sym())); |
| } |
| for (MethodInfo method : info.methods()) { |
| result.add(factory.executableElement(method.sym())); |
| } |
| for (ClassSymbol child : info.children().values()) { |
| result.add(factory.typeElement(child)); |
| } |
| return result.build(); |
| } |
| }); |
| |
| @Override |
| public List<? extends Element> getEnclosedElements() { |
| return enclosed.get(); |
| } |
| |
| @Override |
| public <R, P> R accept(ElementVisitor<R, P> v, P p) { |
| return v.visitType(this, p); |
| } |
| |
| @Override |
| public ClassSymbol sym() { |
| return sym; |
| } |
| |
| @Override |
| public String javadoc() { |
| TypeBoundClass info = info(); |
| if (!(info instanceof SourceTypeBoundClass)) { |
| return null; |
| } |
| return ((SourceTypeBoundClass) info).decl().javadoc(); |
| } |
| |
| @Override |
| public boolean equals(@Nullable Object obj) { |
| return obj instanceof TurbineTypeElement && sym.equals(((TurbineTypeElement) obj).sym); |
| } |
| |
| @Override |
| protected ImmutableList<AnnoInfo> annos() { |
| return infoNonNull().annotations(); |
| } |
| |
| @Override |
| public final <A extends Annotation> A getAnnotation(Class<A> annotationType) { |
| ClassSymbol sym = new ClassSymbol(annotationType.getName().replace('.', '/')); |
| AnnoInfo anno = getAnnotation(annos(), sym); |
| if (anno != null) { |
| return TurbineAnnotationProxy.create(factory, annotationType, anno); |
| } |
| if (!isAnnotationInherited(sym)) { |
| return null; |
| } |
| ClassSymbol superclass = infoNonNull().superclass(); |
| while (superclass != null) { |
| TypeBoundClass info = factory.getSymbol(superclass); |
| if (info == null) { |
| break; |
| } |
| anno = getAnnotation(info.annotations(), sym); |
| if (anno != null) { |
| return TurbineAnnotationProxy.create(factory, annotationType, anno); |
| } |
| superclass = info.superclass(); |
| } |
| return null; |
| } |
| |
| @Override |
| List<? extends AnnotationMirror> getAllAnnotationMirrors() { |
| Map<ClassSymbol, AnnotationMirror> result = new LinkedHashMap<>(); |
| for (AnnoInfo anno : annos()) { |
| result.put(anno.sym(), TurbineAnnotationMirror.create(factory, anno)); |
| } |
| ClassSymbol superclass = infoNonNull().superclass(); |
| while (superclass != null) { |
| TypeBoundClass i = factory.getSymbol(superclass); |
| if (i == null) { |
| break; |
| } |
| for (AnnoInfo anno : i.annotations()) { |
| addAnnotationFromSuper(result, anno); |
| } |
| superclass = i.superclass(); |
| } |
| return ImmutableList.copyOf(result.values()); |
| } |
| |
| private void addAnnotationFromSuper(Map<ClassSymbol, AnnotationMirror> result, AnnoInfo anno) { |
| if (!isAnnotationInherited(anno.sym())) { |
| return; |
| } |
| if (result.containsKey(anno.sym())) { |
| // if the same inherited annotation is present on multiple supertypes, only return one |
| return; |
| } |
| result.put(anno.sym(), TurbineAnnotationMirror.create(factory, anno)); |
| } |
| |
| private boolean isAnnotationInherited(ClassSymbol sym) { |
| TypeBoundClass annoInfo = factory.getSymbol(sym); |
| if (annoInfo == null) { |
| return false; |
| } |
| for (AnnoInfo anno : annoInfo.annotations()) { |
| if (anno.sym().equals(ClassSymbol.INHERITED)) { |
| return true; |
| } |
| } |
| return false; |
| } |
| } |
| |
| /** A {@link TypeParameterElement} implementation backed by a {@link TyVarSymbol}. */ |
| static class TurbineTypeParameterElement extends TurbineElement implements TypeParameterElement { |
| |
| @Override |
| public int hashCode() { |
| return sym.hashCode(); |
| } |
| |
| @Override |
| public boolean equals(@Nullable Object obj) { |
| return obj instanceof TurbineTypeParameterElement |
| && sym.equals(((TurbineTypeParameterElement) obj).sym); |
| } |
| |
| private final TyVarSymbol sym; |
| |
| public TurbineTypeParameterElement(ModelFactory factory, TyVarSymbol sym) { |
| super(factory); |
| this.sym = sym; |
| } |
| |
| private final Supplier<TyVarInfo> info = |
| memoize( |
| new Supplier<TyVarInfo>() { |
| @Override |
| public TyVarInfo get() { |
| return factory.getTyVarInfo(sym); |
| } |
| }); |
| |
| @Nullable |
| private TyVarInfo info() { |
| return info.get(); |
| } |
| |
| @Override |
| public String toString() { |
| return sym.name(); |
| } |
| |
| @Override |
| public Element getGenericElement() { |
| return factory.element(sym.owner()); |
| } |
| |
| @Override |
| public List<? extends TypeMirror> getBounds() { |
| ImmutableList<Type> bounds = info().upperBound().bounds(); |
| return factory.asTypeMirrors(bounds.isEmpty() ? ImmutableList.of(ClassTy.OBJECT) : bounds); |
| } |
| |
| @Override |
| public TypeMirror asType() { |
| return factory.asTypeMirror(Type.TyVar.create(sym, info().annotations())); |
| } |
| |
| @Override |
| public ElementKind getKind() { |
| return ElementKind.TYPE_PARAMETER; |
| } |
| |
| @Override |
| public Set<Modifier> getModifiers() { |
| return ImmutableSet.of(); |
| } |
| |
| @Override |
| public Name getSimpleName() { |
| return new TurbineName(sym.name()); |
| } |
| |
| @Override |
| public Element getEnclosingElement() { |
| return getGenericElement(); |
| } |
| |
| @Override |
| public List<? extends Element> getEnclosedElements() { |
| return ImmutableList.of(); |
| } |
| |
| @Override |
| public <R, P> R accept(ElementVisitor<R, P> v, P p) { |
| return v.visitTypeParameter(this, p); |
| } |
| |
| @Override |
| public TyVarSymbol sym() { |
| return sym; |
| } |
| |
| @Override |
| public String javadoc() { |
| return null; |
| } |
| |
| @Override |
| protected ImmutableList<AnnoInfo> annos() { |
| return info().annotations(); |
| } |
| } |
| |
| /** An {@link ExecutableElement} implementation backed by a {@link MethodSymbol}. */ |
| static class TurbineExecutableElement extends TurbineElement implements ExecutableElement { |
| |
| private final MethodSymbol sym; |
| |
| private final Supplier<MethodInfo> info = |
| memoize( |
| new Supplier<MethodInfo>() { |
| @Override |
| public MethodInfo get() { |
| return factory.getMethodInfo(sym); |
| } |
| }); |
| |
| @Nullable |
| MethodInfo info() { |
| return info.get(); |
| } |
| |
| TurbineExecutableElement(ModelFactory factory, MethodSymbol sym) { |
| super(factory); |
| this.sym = sym; |
| } |
| |
| @Override |
| public MethodSymbol sym() { |
| return sym; |
| } |
| |
| @Override |
| public String javadoc() { |
| MethDecl decl = info().decl(); |
| return decl != null ? decl.javadoc() : null; |
| } |
| |
| @Override |
| public int hashCode() { |
| return sym.hashCode(); |
| } |
| |
| @Override |
| public boolean equals(@Nullable Object obj) { |
| return obj instanceof TurbineExecutableElement |
| && sym.equals(((TurbineExecutableElement) obj).sym); |
| } |
| |
| @Override |
| public List<? extends TypeParameterElement> getTypeParameters() { |
| ImmutableList.Builder<TurbineTypeParameterElement> result = ImmutableList.builder(); |
| for (Map.Entry<TyVarSymbol, TyVarInfo> p : info().tyParams().entrySet()) { |
| result.add(factory.typeParameterElement(p.getKey())); |
| } |
| return result.build(); |
| } |
| |
| @Override |
| public TypeMirror getReturnType() { |
| return factory.asTypeMirror(info().returnType()); |
| } |
| |
| private final Supplier<ImmutableList<VariableElement>> parameters = |
| memoize( |
| new Supplier<ImmutableList<VariableElement>>() { |
| @Override |
| public ImmutableList<VariableElement> get() { |
| ImmutableList.Builder<VariableElement> result = ImmutableList.builder(); |
| for (ParamInfo param : info().parameters()) { |
| if (param.synthetic()) { |
| // ExecutableElement#getParameters doesn't expect synthetic or mandated |
| // parameters |
| continue; |
| } |
| result.add(factory.parameterElement(param.sym())); |
| } |
| return result.build(); |
| } |
| }); |
| |
| @Override |
| public List<? extends VariableElement> getParameters() { |
| return parameters.get(); |
| } |
| |
| @Override |
| public String toString() { |
| MethodInfo info = info(); |
| StringBuilder sb = new StringBuilder(); |
| if (!info.tyParams().isEmpty()) { |
| sb.append('<'); |
| Joiner.on(',').appendTo(sb, info.tyParams().keySet()); |
| sb.append('>'); |
| } |
| if (getKind() == ElementKind.CONSTRUCTOR) { |
| sb.append(info.sym().owner().simpleName()); |
| } else { |
| sb.append(info.sym().name()); |
| } |
| sb.append('('); |
| boolean first = true; |
| for (ParamInfo p : info.parameters()) { |
| if (!first) { |
| sb.append(','); |
| } |
| sb.append(p.type()); |
| first = false; |
| } |
| sb.append(')'); |
| return sb.toString(); |
| } |
| |
| @Override |
| public TypeMirror getReceiverType() { |
| return info().receiver() != null |
| ? factory.asTypeMirror(info().receiver().type()) |
| : factory.noType(); |
| } |
| |
| @Override |
| public boolean isVarArgs() { |
| return (info().access() & TurbineFlag.ACC_VARARGS) == TurbineFlag.ACC_VARARGS; |
| } |
| |
| @Override |
| public boolean isDefault() { |
| return (info().access() & TurbineFlag.ACC_DEFAULT) == TurbineFlag.ACC_DEFAULT; |
| } |
| |
| @Override |
| public List<? extends TypeMirror> getThrownTypes() { |
| return factory.asTypeMirrors(info().exceptions()); |
| } |
| |
| @Override |
| public AnnotationValue getDefaultValue() { |
| return info().defaultValue() != null |
| ? TurbineAnnotationMirror.annotationValue(factory, info().defaultValue()) |
| : null; |
| } |
| |
| @Override |
| public TypeMirror asType() { |
| return factory.asTypeMirror(info().asType()); |
| } |
| |
| @Override |
| public ElementKind getKind() { |
| return sym.name().equals("<init>") ? ElementKind.CONSTRUCTOR : ElementKind.METHOD; |
| } |
| |
| @Override |
| public Set<Modifier> getModifiers() { |
| return asModifierSet(ModifierOwner.METHOD, info().access()); |
| } |
| |
| @Override |
| public Name getSimpleName() { |
| return new TurbineName(info().sym().name()); |
| } |
| |
| @Override |
| public Element getEnclosingElement() { |
| return factory.typeElement(info().sym().owner()); |
| } |
| |
| @Override |
| public List<? extends Element> getEnclosedElements() { |
| return ImmutableList.of(); |
| } |
| |
| @Override |
| public <R, P> R accept(ElementVisitor<R, P> v, P p) { |
| return v.visitExecutable(this, p); |
| } |
| |
| @Override |
| protected ImmutableList<AnnoInfo> annos() { |
| return info().annotations(); |
| } |
| } |
| |
| /** An {@link VariableElement} implementation backed by a {@link FieldSymbol}. */ |
| static class TurbineFieldElement extends TurbineElement implements VariableElement { |
| |
| @Override |
| public String toString() { |
| return sym.name(); |
| } |
| |
| @Override |
| public boolean equals(@Nullable Object obj) { |
| return obj instanceof TurbineFieldElement && sym.equals(((TurbineFieldElement) obj).sym); |
| } |
| |
| @Override |
| public int hashCode() { |
| return sym.hashCode(); |
| } |
| |
| private final FieldSymbol sym; |
| |
| @Override |
| public FieldSymbol sym() { |
| return sym; |
| } |
| |
| @Override |
| public String javadoc() { |
| VarDecl decl = info().decl(); |
| return decl != null ? decl.javadoc() : null; |
| } |
| |
| private final Supplier<FieldInfo> info = |
| memoize( |
| new Supplier<FieldInfo>() { |
| @Override |
| public FieldInfo get() { |
| return factory.getFieldInfo(sym); |
| } |
| }); |
| |
| @Nullable |
| FieldInfo info() { |
| return info.get(); |
| } |
| |
| TurbineFieldElement(ModelFactory factory, FieldSymbol sym) { |
| super(factory); |
| this.sym = sym; |
| } |
| |
| @Override |
| public Object getConstantValue() { |
| if (info().value() == null) { |
| return null; |
| } |
| return info().value().getValue(); |
| } |
| |
| @Override |
| public TypeMirror asType() { |
| return factory.asTypeMirror(info().type()); |
| } |
| |
| @Override |
| public ElementKind getKind() { |
| return ((info().access() & TurbineFlag.ACC_ENUM) == TurbineFlag.ACC_ENUM) |
| ? ElementKind.ENUM_CONSTANT |
| : ElementKind.FIELD; |
| } |
| |
| @Override |
| public Set<Modifier> getModifiers() { |
| return asModifierSet(ModifierOwner.FIELD, info().access()); |
| } |
| |
| @Override |
| public Name getSimpleName() { |
| return new TurbineName(sym.name()); |
| } |
| |
| @Override |
| public Element getEnclosingElement() { |
| return factory.typeElement(sym.owner()); |
| } |
| |
| @Override |
| public List<? extends Element> getEnclosedElements() { |
| return ImmutableList.of(); |
| } |
| |
| @Override |
| public <R, P> R accept(ElementVisitor<R, P> v, P p) { |
| return v.visitVariable(this, p); |
| } |
| |
| @Override |
| protected ImmutableList<AnnoInfo> annos() { |
| return info().annotations(); |
| } |
| } |
| |
| private enum ModifierOwner { |
| TYPE, |
| PARAMETER, |
| FIELD, |
| METHOD |
| } |
| |
| private static ImmutableSet<Modifier> asModifierSet(ModifierOwner modifierOwner, int access) { |
| EnumSet<Modifier> modifiers = EnumSet.noneOf(Modifier.class); |
| if ((access & TurbineFlag.ACC_PUBLIC) == TurbineFlag.ACC_PUBLIC) { |
| modifiers.add(Modifier.PUBLIC); |
| } |
| if ((access & TurbineFlag.ACC_PROTECTED) == TurbineFlag.ACC_PROTECTED) { |
| modifiers.add(Modifier.PROTECTED); |
| } |
| if ((access & TurbineFlag.ACC_PRIVATE) == TurbineFlag.ACC_PRIVATE) { |
| modifiers.add(Modifier.PRIVATE); |
| } |
| if ((access & TurbineFlag.ACC_ABSTRACT) == TurbineFlag.ACC_ABSTRACT) { |
| modifiers.add(Modifier.ABSTRACT); |
| } |
| if ((access & TurbineFlag.ACC_FINAL) == TurbineFlag.ACC_FINAL) { |
| modifiers.add(Modifier.FINAL); |
| } |
| if ((access & TurbineFlag.ACC_DEFAULT) == TurbineFlag.ACC_DEFAULT) { |
| modifiers.add(Modifier.DEFAULT); |
| } |
| if ((access & TurbineFlag.ACC_STATIC) == TurbineFlag.ACC_STATIC) { |
| modifiers.add(Modifier.STATIC); |
| } |
| if ((access & TurbineFlag.ACC_TRANSIENT) == TurbineFlag.ACC_TRANSIENT) { |
| switch (modifierOwner) { |
| case METHOD: |
| case PARAMETER: |
| // varargs and transient use the same bits |
| break; |
| default: |
| modifiers.add(Modifier.TRANSIENT); |
| } |
| } |
| if ((access & TurbineFlag.ACC_VOLATILE) == TurbineFlag.ACC_VOLATILE) { |
| modifiers.add(Modifier.VOLATILE); |
| } |
| if ((access & TurbineFlag.ACC_SYNCHRONIZED) == TurbineFlag.ACC_SYNCHRONIZED) { |
| modifiers.add(Modifier.SYNCHRONIZED); |
| } |
| if ((access & TurbineFlag.ACC_NATIVE) == TurbineFlag.ACC_NATIVE) { |
| modifiers.add(Modifier.NATIVE); |
| } |
| if ((access & TurbineFlag.ACC_STRICT) == TurbineFlag.ACC_STRICT) { |
| modifiers.add(Modifier.STRICTFP); |
| } |
| |
| return Sets.immutableEnumSet(modifiers); |
| } |
| |
| /** A {@link PackageElement} implementation backed by a {@link PackageSymbol}. */ |
| static class TurbinePackageElement extends TurbineElement implements PackageElement { |
| |
| private final PackageSymbol sym; |
| |
| public TurbinePackageElement(ModelFactory factory, PackageSymbol sym) { |
| super(factory); |
| this.sym = sym; |
| } |
| |
| @Override |
| public Name getQualifiedName() { |
| return new TurbineName(sym.toString()); |
| } |
| |
| @Override |
| public boolean isUnnamed() { |
| return sym.binaryName().isEmpty(); |
| } |
| |
| @Override |
| public TypeMirror asType() { |
| return factory.packageType(sym); |
| } |
| |
| @Override |
| public ElementKind getKind() { |
| return ElementKind.PACKAGE; |
| } |
| |
| @Override |
| public Set<Modifier> getModifiers() { |
| return ImmutableSet.of(); |
| } |
| |
| @Override |
| public Name getSimpleName() { |
| return new TurbineName(sym.binaryName().substring(sym.binaryName().lastIndexOf('/') + 1)); |
| } |
| |
| @Override |
| public Element getEnclosingElement() { |
| // a package is not enclosed by another element |
| return null; |
| } |
| |
| @Override |
| public List<TurbineTypeElement> getEnclosedElements() { |
| ImmutableSet.Builder<TurbineTypeElement> result = ImmutableSet.builder(); |
| PackageScope scope = factory.tli().lookupPackage(Splitter.on('/').split(sym.binaryName())); |
| requireNonNull(scope); // the current package exists |
| for (ClassSymbol key : scope.classes()) { |
| if (key.binaryName().contains("$") && factory.getSymbol(key).owner() != null) { |
| // Skip member classes: only top-level classes are enclosed by the package. |
| // The initial check for '$' is an optimization. |
| continue; |
| } |
| if (key.simpleName().equals("package-info")) { |
| continue; |
| } |
| result.add(factory.typeElement(key)); |
| } |
| return result.build().asList(); |
| } |
| |
| @Override |
| public <R, P> R accept(ElementVisitor<R, P> v, P p) { |
| return v.visitPackage(this, p); |
| } |
| |
| @Override |
| public PackageSymbol sym() { |
| return sym; |
| } |
| |
| @Override |
| public String javadoc() { |
| return null; |
| } |
| |
| @Override |
| public int hashCode() { |
| return sym.hashCode(); |
| } |
| |
| @Override |
| public boolean equals(@Nullable Object obj) { |
| return obj instanceof TurbinePackageElement && sym.equals(((TurbinePackageElement) obj).sym); |
| } |
| |
| private final Supplier<ImmutableList<AnnoInfo>> annos = |
| memoize( |
| new Supplier<ImmutableList<AnnoInfo>>() { |
| @Override |
| public ImmutableList<AnnoInfo> get() { |
| TypeBoundClass info = |
| factory.getSymbol(new ClassSymbol(sym.binaryName() + "/package-info")); |
| return info != null ? info.annotations() : ImmutableList.of(); |
| } |
| }); |
| |
| @Override |
| protected ImmutableList<AnnoInfo> annos() { |
| return annos.get(); |
| } |
| |
| @Override |
| public String toString() { |
| return sym.toString(); |
| } |
| } |
| |
| /** A {@link VariableElement} implementation backed by a {@link ParamSymbol}. */ |
| static class TurbineParameterElement extends TurbineElement implements VariableElement { |
| |
| @Override |
| public ParamSymbol sym() { |
| return sym; |
| } |
| |
| @Override |
| public String javadoc() { |
| return null; |
| } |
| |
| @Override |
| public int hashCode() { |
| return sym.hashCode(); |
| } |
| |
| @Override |
| public boolean equals(@Nullable Object obj) { |
| return obj instanceof TurbineParameterElement |
| && sym.equals(((TurbineParameterElement) obj).sym); |
| } |
| |
| private final ParamSymbol sym; |
| |
| private final Supplier<ParamInfo> info = |
| memoize( |
| new Supplier<ParamInfo>() { |
| @Override |
| public ParamInfo get() { |
| return factory.getParamInfo(sym); |
| } |
| }); |
| |
| @Nullable |
| ParamInfo info() { |
| return info.get(); |
| } |
| |
| public TurbineParameterElement(ModelFactory factory, ParamSymbol sym) { |
| super(factory); |
| this.sym = sym; |
| } |
| |
| @Override |
| public Object getConstantValue() { |
| return null; |
| } |
| |
| private final Supplier<TypeMirror> type = |
| memoize( |
| new Supplier<TypeMirror>() { |
| @Override |
| public TypeMirror get() { |
| return factory.asTypeMirror(info().type()); |
| } |
| }); |
| |
| @Override |
| public TypeMirror asType() { |
| return type.get(); |
| } |
| |
| @Override |
| public ElementKind getKind() { |
| return ElementKind.PARAMETER; |
| } |
| |
| @Override |
| public Set<Modifier> getModifiers() { |
| return asModifierSet(ModifierOwner.PARAMETER, info().access()); |
| } |
| |
| @Override |
| public Name getSimpleName() { |
| return new TurbineName(sym.name()); |
| } |
| |
| @Override |
| public Element getEnclosingElement() { |
| return factory.executableElement(sym.owner()); |
| } |
| |
| @Override |
| public List<? extends Element> getEnclosedElements() { |
| return ImmutableList.of(); |
| } |
| |
| @Override |
| public <R, P> R accept(ElementVisitor<R, P> v, P p) { |
| return v.visitVariable(this, p); |
| } |
| |
| @Override |
| public String toString() { |
| return String.valueOf(sym.name()); |
| } |
| |
| @Override |
| protected ImmutableList<AnnoInfo> annos() { |
| return info().annotations(); |
| } |
| } |
| |
| static class TurbineNoTypeElement implements TypeElement { |
| |
| private final ModelFactory factory; |
| private final String name; |
| |
| public TurbineNoTypeElement(ModelFactory factory, String name) { |
| this.factory = factory; |
| this.name = requireNonNull(name); |
| } |
| |
| @Override |
| public TypeMirror asType() { |
| return factory.noType(); |
| } |
| |
| @Override |
| public ElementKind getKind() { |
| return ElementKind.CLASS; |
| } |
| |
| @Override |
| public Set<Modifier> getModifiers() { |
| return ImmutableSet.of(); |
| } |
| |
| @Override |
| public Name getSimpleName() { |
| return new TurbineName(name.substring(name.lastIndexOf('.') + 1)); |
| } |
| |
| @Override |
| public TypeMirror getSuperclass() { |
| return factory.noType(); |
| } |
| |
| @Override |
| public List<? extends TypeMirror> getInterfaces() { |
| return ImmutableList.of(); |
| } |
| |
| @Override |
| public List<? extends TypeParameterElement> getTypeParameters() { |
| return ImmutableList.of(); |
| } |
| |
| @Override |
| public Element getEnclosingElement() { |
| int idx = name.lastIndexOf('.'); |
| String packageName; |
| if (idx == -1) { |
| packageName = ""; |
| } else { |
| packageName = name.substring(0, idx).replace('.', '/'); |
| } |
| return factory.packageElement(new PackageSymbol(packageName)); |
| } |
| |
| @Override |
| public List<? extends Element> getEnclosedElements() { |
| return ImmutableList.of(); |
| } |
| |
| @Override |
| public NestingKind getNestingKind() { |
| return NestingKind.TOP_LEVEL; |
| } |
| |
| @Override |
| public Name getQualifiedName() { |
| return new TurbineName(name); |
| } |
| |
| @Override |
| public List<? extends AnnotationMirror> getAnnotationMirrors() { |
| return ImmutableList.of(); |
| } |
| |
| @Override |
| public <A extends Annotation> A getAnnotation(Class<A> aClass) { |
| return null; |
| } |
| |
| @Override |
| public <A extends Annotation> A[] getAnnotationsByType(Class<A> aClass) { |
| return null; |
| } |
| |
| @Override |
| public <R, P> R accept(ElementVisitor<R, P> elementVisitor, P p) { |
| return elementVisitor.visitType(this, p); |
| } |
| |
| @Override |
| public String toString() { |
| return getSimpleName().toString(); |
| } |
| } |
| } |
