20 | */
21 | enum DeclarationType {
22 | /**
23 | * We're looking for a type
24 | */
25 | TYPE,
26 | /**
27 | * We're looking for an attribute
28 | */
29 | VALUE;
30 | }
31 |
32 | /**
33 | * Loads a declaration by name and type
34 | *
35 | * @param module the module to load it from
36 | * @param typeName the fully-qualified declaration name
37 | * @param declarationType the declaration type
38 | * @return the declaration, if found, or null.
39 | */
40 | public Declaration getDeclaration(Module module, String typeName, DeclarationType declarationType);
41 |
42 | /**
43 | * Returns the Type of a name in a given scope
44 |
45 | * @param module the module to load it from
46 | * @param pkg the package name
47 | * @param name the fully-qualified name of the type
48 | * @param scope the scope in which to find it
49 | * @return the Type found
50 | */
51 | public Type getType(Module module, String pkg, String name, Scope scope);
52 |
53 | /**
54 | * Returns the Declaration of a name in a given scope
55 |
56 | * @param module the module to load it from
57 | * @param pkg the package name
58 | * @param name the fully-qualified name of the type
59 | * @param scope the scope in which to find it
60 | * @return the Type found
61 | */
62 | public Declaration getDeclaration(Module module, String pkg, String name, Scope scope);
63 |
64 | /**
65 | * Returns a loaded module by name and version
66 | * @return null if module is not already loaded
67 | */
68 | public Module getLoadedModule(String moduleName, String version);
69 | }
70 |
--------------------------------------------------------------------------------
/src/com/redhat/ceylon/model/loader/ModelResolutionException.java:
--------------------------------------------------------------------------------
1 | package com.redhat.ceylon.model.loader;
2 |
3 | @SuppressWarnings("serial")
4 | public class ModelResolutionException extends RuntimeException {
5 |
6 | public ModelResolutionException() {
7 | super();
8 | }
9 |
10 | public ModelResolutionException(String message, Throwable cause) {
11 | super(message, cause);
12 | }
13 |
14 | public ModelResolutionException(String message) {
15 | super(message);
16 | }
17 |
18 | public ModelResolutionException(Throwable cause) {
19 | super(cause);
20 | }
21 |
22 | }
23 |
--------------------------------------------------------------------------------
/src/com/redhat/ceylon/model/loader/ParameterNameLexer.java:
--------------------------------------------------------------------------------
1 | package com.redhat.ceylon.model.loader;
2 |
3 | class ParameterNameLexer {
4 |
5 | public static final int COMMA = 0;
6 | public static final int LEFT_PAREN = COMMA+1;
7 | public static final int RIGHT_PAREN = LEFT_PAREN+1;
8 | public static final int IDENT = RIGHT_PAREN+1;
9 | public static final int PLUS = IDENT+1;
10 | public static final int STAR = PLUS+1;
11 | public static final int BANG = STAR+1;
12 | public static final int EOI = BANG+1;
13 |
14 | // type string to parse
15 | String input;
16 | int index = 0;
17 | int mark = -1;
18 |
19 | public ParameterNameLexer(){}
20 |
21 | public String toString() {
22 | StringBuilder sb = new StringBuilder();
23 | sb.append(input).append(System.lineSeparator());
24 | for (int ii = 0; ii < index; ii++) {
25 | sb.append(' ');
26 | }
27 | sb.append('^');
28 | return sb.toString();
29 | }
30 |
31 | public void setup(String input){
32 | this.input = input;
33 | index = 0;
34 | }
35 |
36 | private int peek(){
37 | if(index >= input.length())
38 | return EOI;
39 | int c = input.codePointAt(index);
40 | int token;
41 | switch(c){
42 | case '(': token = LEFT_PAREN; break;
43 | case ')': token = RIGHT_PAREN; break;
44 | case ',': token = COMMA; break;
45 | case '+': token = PLUS; break;
46 | case '*': token = STAR; break;
47 | case '!': token = BANG; break;
48 | default:
49 | if (isIdentifierPart(c)) {
50 | token = IDENT;
51 | } else {
52 | throw new ParameterNameParserException("Unknown codepoint=" + c + "\n" + this);
53 | }
54 | }
55 | return token;
56 | }
57 |
58 | private boolean isIdentifierPart(int codepoint) {
59 | return Character.isLowerCase(codepoint)
60 | || Character.isUpperCase(codepoint)
61 | || Character.isDigit(codepoint)
62 | || codepoint == '_';
63 | }
64 |
65 | public void eat() {
66 | int token = peek();
67 | switch(token) {
68 | case LEFT_PAREN:
69 | case RIGHT_PAREN:
70 | case COMMA:
71 | case PLUS:
72 | case STAR:
73 | case BANG:
74 | index += 1;
75 | return;
76 | case IDENT:
77 | index += Character.charCount(input.codePointAt(index));
78 | int c = input.codePointAt(index);
79 | while (index < input.length()
80 | && isIdentifierPart(c)) {
81 | index += Character.charCount(input.codePointAt(index));
82 | c = input.codePointAt(index);
83 | }
84 | return;
85 | case EOI:
86 | return;
87 | default:
88 | throw new ParameterNameParserException("Unknown token=" + token+"\n" + this);
89 | }
90 | }
91 |
92 | public String eatIdentifier() {
93 | int index = this.index;
94 | eat(IDENT);
95 | return input.substring(index, this.index);
96 | }
97 |
98 | public void eat(int token) {
99 | if(!lookingAt(token)){
100 | throw new ParameterNameParserException("Missing expected token: "+tokenToString(token)+System.lineSeparator()
101 | + this);
102 | }
103 | eat();
104 | }
105 |
106 | private String tokenToString(int token) {
107 | switch (token) {
108 | case COMMA: return "COMMA";
109 | case IDENT: return "IDENT";
110 | case LEFT_PAREN: return "LEFT_PAREN";
111 | case RIGHT_PAREN: return "RIGHT_PAREN";
112 | case EOI: return "EOI";
113 | case PLUS: return "PLUS";
114 | case STAR: return "STAR";
115 | case BANG: return "BANG";
116 | }
117 | throw new ParameterNameParserException("Unknown token " + token);
118 | }
119 |
120 | public boolean lookingAt(int token) {
121 | return peek() == token;
122 | }
123 |
124 | }
125 |
--------------------------------------------------------------------------------
/src/com/redhat/ceylon/model/loader/ParameterNameParser.java:
--------------------------------------------------------------------------------
1 | package com.redhat.ceylon.model.loader;
2 |
3 | import static com.redhat.ceylon.model.loader.ParameterNameLexer.*;
4 |
5 | import java.util.ArrayList;
6 | import java.util.Iterator;
7 | import java.util.List;
8 |
9 | import com.redhat.ceylon.model.typechecker.model.Function;
10 | import com.redhat.ceylon.model.typechecker.model.FunctionOrValue;
11 | import com.redhat.ceylon.model.typechecker.model.Parameter;
12 | import com.redhat.ceylon.model.typechecker.model.ParameterList;
13 | import com.redhat.ceylon.model.typechecker.model.Type;
14 | import com.redhat.ceylon.model.typechecker.model.Unit;
15 | import com.redhat.ceylon.model.typechecker.model.Value;
16 |
17 | /**
18 | * Parser for {@link com.redhat.ceylon.compiler.java.metadata.FunctionalParameter#value()}.
19 | *
20 | * input ::= ( '!' )? nameList ( nameList )*
21 | * nameList ::= '(' ( name ( ',' name )* )? ')'
22 | * name ::= identifier ( '+' | '*' )? ( '!' )? ( nameList )*
23 | *
24 | *
25 | * - A {@code !} means that the {@code Function} model is declared {@code void}
26 | * - A {@code +} means that the {@code Parameter} model is possibly-empty variadic
27 | * - A {@code *} means that the {@code Parameter} model is nonempty variadic
28 | *
29 | * @author tom
30 | */
31 | class ParameterNameParser {
32 |
33 | private final ParameterNameLexer lexer = new ParameterNameLexer();
34 | private final AbstractModelLoader loader;
35 | private Unit unit;
36 |
37 |
38 |
39 | ParameterNameParser(AbstractModelLoader loader) {
40 | this.loader = loader;
41 | }
42 |
43 | public void parse(String input, Type type, Function method) {
44 | lexer.setup(input);
45 | this.unit = method.getUnit();
46 | boolean declaredVoid = false;
47 | ArrayList lists = new ArrayList<>();
48 | if (lexer.lookingAt(BANG)) {
49 | lexer.eat();
50 | declaredVoid = true;
51 | }
52 | lists.add(parseNameList(type, method));
53 | while (lexer.lookingAt(LEFT_PAREN)) {// mpl
54 | type = loader.getSimpleCallableReturnType(type);
55 | lists.add(parseNameList(type, method));
56 | }
57 | for (ParameterList parameterList : lists) {
58 | method.addParameterList(parameterList);
59 | }
60 | method.setDeclaredVoid(declaredVoid);
61 | method.setType(loader.getSimpleCallableReturnType(type));
62 | if (!lexer.lookingAt(EOI)) {
63 | throw new ParameterNameParserException("Expected end of input" + System.lineSeparator() + input);
64 | }
65 | }
66 | public void parseMpl(String input, Type type, Function method) {
67 | lexer.setup(input);
68 | this.unit = method.getUnit();
69 | ArrayList lists = new ArrayList<>();
70 | lists.add(parseNameList(type, method));
71 | while (lexer.lookingAt(LEFT_PAREN)) {// mpl
72 | type = loader.getSimpleCallableReturnType(type);
73 | lists.add(parseNameList(type, method));
74 | }
75 | for (ParameterList parameterList : lists) {
76 | method.addParameterList(parameterList);
77 | }
78 | method.setType(loader.getSimpleCallableReturnType(type));
79 | if (!lexer.lookingAt(EOI)) {
80 | throw new ParameterNameParserException("Expected end of input" + System.lineSeparator() + input);
81 | }
82 | }
83 | private ParameterList parseNameList(Type type, Function method) {
84 | ParameterList pl = new ParameterList();
85 | List parameters = pl.getParameters();
86 | //startParameterList();
87 | lexer.eat(LEFT_PAREN);
88 | if (!lexer.lookingAt(RIGHT_PAREN)) {
89 | Iterator ct = loader.getSimpleCallableArgumentTypes(type).iterator();
90 | if (!ct.hasNext()) {
91 | throw new ParameterNameParserException("Too few parameter types");
92 | }
93 | parameters.add(parseName(ct.next(), method));
94 | // addParameter()
95 | while (lexer.lookingAt(COMMA)) {
96 | lexer.eat();
97 | if (!ct.hasNext()) {
98 | throw new ParameterNameParserException("Too few parameter types");
99 | }
100 | parameters.add(parseName(ct.next(), method));
101 | }
102 | if (ct.hasNext()) {
103 | throw new ParameterNameParserException("Too many parameter types");
104 | }
105 | }
106 | lexer.eat(RIGHT_PAREN);
107 | //endParameterList();
108 | return pl;
109 | }
110 |
111 | private Parameter parseName(Type type, Function container) {
112 | String identifier = lexer.eatIdentifier();
113 | boolean declaredVoid = false;
114 | boolean sequenced = false;
115 | boolean atLeastOne = false;
116 | if (lexer.lookingAt(STAR)) {
117 | lexer.eat();
118 | sequenced = true;
119 | } else if (lexer.lookingAt(PLUS)) {
120 | lexer.eat();
121 | sequenced = true;
122 | atLeastOne = true;
123 | }
124 | if (lexer.lookingAt(BANG)) {
125 | lexer.eat();
126 | declaredVoid = true;
127 | }
128 |
129 | final FunctionOrValue result;
130 | if (lexer.lookingAt(LEFT_PAREN)) {
131 | // functionParameter()
132 | result = parseMethod(type, declaredVoid);
133 | } else {
134 | if (declaredVoid) {
135 | throw new ParameterNameParserException("void Value");
136 | }
137 | // valueParameter();
138 | result = parseValue(type);
139 | }
140 | result.setName(identifier);
141 | result.setUnit(unit);
142 | result.setContainer(container);
143 | result.setScope(container);
144 | Parameter p = new Parameter();
145 | p.setName(identifier);
146 | p.setSequenced(sequenced);
147 | p.setAtLeastOne(atLeastOne);
148 | p.setDeclaredAnything(declaredVoid);
149 | p.setModel(result);
150 | result.setInitializerParameter(p);
151 | container.addMember(result);
152 | return p;
153 | }
154 |
155 | private Value parseValue(Type type) {
156 | Value value = new Value();
157 | value.setType(type);
158 | return value;
159 | }
160 |
161 | private Function parseMethod(Type type, boolean declaredVoid) {
162 | Function method = new Function();
163 | method.setDeclaredVoid(declaredVoid);
164 | method.setType(loader.getSimpleCallableReturnType(type));
165 | while (lexer.lookingAt(LEFT_PAREN)) {
166 | method.addParameterList(parseNameList(type, method));
167 | type = loader.getSimpleCallableReturnType(type);
168 | }
169 | return method;
170 | }
171 |
172 | }
173 |
--------------------------------------------------------------------------------
/src/com/redhat/ceylon/model/loader/ParameterNameParserException.java:
--------------------------------------------------------------------------------
1 | package com.redhat.ceylon.model.loader;
2 |
3 | @SuppressWarnings("serial")
4 | class ParameterNameParserException extends RuntimeException {
5 |
6 | public ParameterNameParserException(String message) {
7 | super(message);
8 | }
9 |
10 | }
11 |
--------------------------------------------------------------------------------
/src/com/redhat/ceylon/model/loader/SimpleReflType.java:
--------------------------------------------------------------------------------
1 | package com.redhat.ceylon.model.loader;
2 |
3 | import java.util.Arrays;
4 | import java.util.List;
5 |
6 | import javax.lang.model.type.TypeKind;
7 |
8 | import com.redhat.ceylon.model.loader.mirror.ClassMirror;
9 | import com.redhat.ceylon.model.loader.mirror.TypeMirror;
10 | import com.redhat.ceylon.model.loader.mirror.TypeParameterMirror;
11 |
12 | /**
13 | * Simple Type Mirror.
14 | *
15 | * @author Stéphane Épardaud
16 | */
17 | public class SimpleReflType implements TypeMirror {
18 |
19 | public enum Module {
20 | CEYLON, JDK;
21 | }
22 |
23 | private String name;
24 | private TypeKind kind;
25 | private TypeMirror[] typeParameters;
26 | private Module module;
27 |
28 | public SimpleReflType(String name, Module module, TypeKind kind, TypeMirror... typeParameters) {
29 | this.name = name;
30 | this.kind = kind;
31 | this.typeParameters = typeParameters;
32 | this.module = module;
33 | }
34 |
35 | public String toString() {
36 | String p = Arrays.toString(typeParameters);
37 | return getClass().getSimpleName() + " of " + name + "<" + p.substring(1, p.length()-1) + ">";
38 | }
39 |
40 | @Override
41 | public String getQualifiedName() {
42 | return name;
43 | }
44 |
45 | @Override
46 | public List getTypeArguments() {
47 | return Arrays.asList(typeParameters);
48 | }
49 |
50 | @Override
51 | public TypeKind getKind() {
52 | return kind;
53 | }
54 |
55 | @Override
56 | public TypeMirror getComponentType() {
57 | return null;
58 | }
59 |
60 | @Override
61 | public boolean isPrimitive() {
62 | return kind.isPrimitive();
63 | }
64 |
65 | @Override
66 | public TypeMirror getUpperBound() {
67 | return null;
68 | }
69 |
70 | @Override
71 | public TypeMirror getLowerBound() {
72 | return null;
73 | }
74 |
75 | @Override
76 | public boolean isRaw() {
77 | return false;
78 | }
79 |
80 | @Override
81 | public ClassMirror getDeclaredClass() {
82 | return null;
83 | }
84 |
85 | public Module getModule() {
86 | return module;
87 | }
88 |
89 | @Override
90 | public TypeParameterMirror getTypeParameter() {
91 | return null;
92 | }
93 |
94 | @Override
95 | public TypeMirror getQualifyingType() {
96 | return null;
97 | }
98 | }
99 |
--------------------------------------------------------------------------------
/src/com/redhat/ceylon/model/loader/Timer.java:
--------------------------------------------------------------------------------
1 | package com.redhat.ceylon.model.loader;
2 |
3 | import java.io.PrintWriter;
4 | import java.util.HashMap;
5 | import java.util.Map;
6 |
7 | public class Timer {
8 | private long programStart;
9 | private String currentTask;
10 | private long currentTaskStart;
11 | protected boolean verbose;
12 | private final Map ignoredCategories;
13 | protected PrintWriter out;
14 |
15 | protected Timer(){
16 | ignoredCategories = new HashMap();
17 | }
18 |
19 | private Timer(PrintWriter out, long programStart, boolean verbose, Map ignoredCategories) {
20 | this.programStart = programStart;
21 | this.verbose = verbose;
22 | this.ignoredCategories = ignoredCategories;
23 | this.out = out;
24 | }
25 |
26 | public Timer(boolean verbose) {
27 | ignoredCategories = new HashMap();
28 | setup(verbose);
29 | }
30 |
31 | private void setup(boolean verbose) {
32 | // we delay printing the program start because we don't know if the verbose option is set yet at
33 | // that time, so we fake it later on with the correct time
34 | }
35 |
36 | /**
37 | * Initializes this timer and {@linkplain #log(String) logs} a
38 | * "program start" message.
39 | */
40 | public void init(){
41 | programStart = System.nanoTime();
42 | if(verbose)
43 | log("Program start", programStart);
44 | }
45 |
46 | public void end() {
47 | if(!verbose)
48 | return;
49 | log("Program end");
50 | }
51 |
52 | /**
53 | * {@linkplain #endTask() Ends} the current task (if any) and starts a
54 | * timed task with the given name,
55 | * {@linkplain #log(String) logging} the task name.
56 | *
57 | * @param name The name of the task to start.
58 | *
59 | * @see #nestedTimer()
60 | */
61 | public void startTask(String name){
62 | if(!verbose)
63 | return;
64 | if(currentTask != null)
65 | endTask();
66 | currentTask = name;
67 | currentTaskStart = System.nanoTime();
68 | log("Task "+currentTask+" start");
69 | }
70 |
71 | /**
72 | * Logs a message, including the elapsed time since this Timer was
73 | * {@linkplain #init() initialized}.
74 | * @param string The message
75 | */
76 | public void log(String string) {
77 | if(!verbose)
78 | return;
79 | log(string, System.nanoTime());
80 | }
81 |
82 | private void log(String string, long now) {
83 | long delta = (now - programStart)/1_000_000;
84 | String msg = "["+delta+"ms] "+string;
85 | if(out != null)
86 | out.println(msg);
87 | else
88 | System.err.println(msg);
89 | }
90 |
91 | /**
92 | * Prints a message
93 | * @param string The message
94 | */
95 | public void print(String string) {
96 | if(!verbose)
97 | return;
98 | if(out != null)
99 | out.println(string);
100 | else
101 | System.err.println(string);
102 | }
103 |
104 | /**
105 | * Ends the current task, {@linkplain #log(String) logging} the name of
106 | * the task and its elapsed time
107 | * @see #startTask(String)
108 | */
109 | public void endTask() {
110 | if(!verbose)
111 | return;
112 | long time = System.nanoTime();
113 | long delta = (time - currentTaskStart)/1_000_000L;
114 | log("Task "+currentTask+" end: "+delta+"ms");
115 | printIgnoredCategories();
116 | currentTask = null;
117 | }
118 |
119 | public void startIgnore(String category) {
120 | if(!verbose)
121 | return;
122 | IgnoredCategory ignoredCategory = ignoredCategories.get(category);
123 | if(ignoredCategory == null){
124 | ignoredCategory = new IgnoredCategory(category);
125 | ignoredCategories.put(category, ignoredCategory);
126 | }
127 | ignoredCategory.start();
128 | }
129 |
130 | public void stopIgnore(String category) {
131 | if(!verbose)
132 | return;
133 | IgnoredCategory ignoredCategory = ignoredCategories.get(category);
134 | if (ignoredCategory != null) {
135 | ignoredCategory.stop();
136 | }
137 | }
138 |
139 | private void printIgnoredCategories(){
140 | for(IgnoredCategory category : ignoredCategories.values()){
141 | if(category.total != 0){
142 | print(" Including "+category.name+" for "+category.total+"ms");
143 | }
144 | category.reset();
145 | }
146 | }
147 |
148 | private final class IgnoredCategory {
149 | String name;
150 | long start;
151 | long total;
152 | int count;
153 | public IgnoredCategory(String category) {
154 | this.name = category;
155 | }
156 | public void start() {
157 | if(count++ == 0){
158 | start = System.nanoTime();
159 | }
160 | }
161 | public void stop() {
162 | if(--count == 0){
163 | long end = System.nanoTime();
164 | long delta = (end - start)/1_000_000;
165 | total += delta;
166 | }
167 | }
168 | public void reset() {
169 | if(count != 0)
170 | print("Ignored category "+name+" count is "+count+" during reset: timings will be wrong");
171 | // try to fix it for next time?
172 | count = 0;
173 | total = 0;
174 | }
175 | }
176 |
177 | /**
178 | * Creates and returns a new timer suitable for timing sub-tasks
179 | * without stopping the 'outer' timer. Necessary because
180 | * {@link #startTask(String)} stops the current timer.
181 | * @return The new timer
182 | */
183 | public Timer nestedTimer() {
184 | return new Timer(out, programStart, verbose, ignoredCategories);
185 | }
186 | }
187 |
--------------------------------------------------------------------------------
/src/com/redhat/ceylon/model/loader/TypeParserException.java:
--------------------------------------------------------------------------------
1 | package com.redhat.ceylon.model.loader;
2 |
3 | @SuppressWarnings("serial")
4 | public class TypeParserException extends RuntimeException {
5 |
6 | public TypeParserException(String message) {
7 | super(message);
8 | }
9 |
10 | }
11 |
--------------------------------------------------------------------------------
/src/com/redhat/ceylon/model/loader/impl/reflect/ReflectionModelLoader.java:
--------------------------------------------------------------------------------
1 | package com.redhat.ceylon.model.loader.impl.reflect;
2 |
3 | import java.lang.reflect.Member;
4 | import java.util.List;
5 |
6 | import com.redhat.ceylon.common.JVMModuleUtil;
7 | import com.redhat.ceylon.common.log.Logger;
8 | import com.redhat.ceylon.model.loader.AbstractModelLoader;
9 | import com.redhat.ceylon.model.loader.Timer;
10 | import com.redhat.ceylon.model.loader.TypeParser;
11 | import com.redhat.ceylon.model.loader.impl.reflect.mirror.ReflectionClass;
12 | import com.redhat.ceylon.model.loader.impl.reflect.mirror.ReflectionMethod;
13 | import com.redhat.ceylon.model.loader.mirror.ClassMirror;
14 | import com.redhat.ceylon.model.loader.mirror.MethodMirror;
15 | import com.redhat.ceylon.model.typechecker.model.Module;
16 | import com.redhat.ceylon.model.typechecker.model.Modules;
17 | import com.redhat.ceylon.model.typechecker.model.Unit;
18 | import com.redhat.ceylon.model.typechecker.util.ModuleManager;
19 |
20 | /**
21 | * A model loader which uses Java reflection.
22 | *
23 | * @author Stéphane Épardaud
24 | */
25 | public abstract class ReflectionModelLoader extends AbstractModelLoader {
26 | protected Logger log;
27 |
28 | public ReflectionModelLoader(ModuleManager moduleManager, Modules modules, Logger log){
29 | this.moduleManager = moduleManager;
30 | this.modules = modules;
31 | this.typeFactory = new Unit();
32 | this.typeParser = new TypeParser(this);
33 | this.timer = new Timer(false);
34 | this.log = log;
35 | }
36 |
37 | protected abstract List getPackageList(Module module, String packageName);
38 | protected abstract boolean packageExists(Module module, String packageName);
39 | protected abstract Class loadClass(Module module, String name);
40 |
41 | @Override
42 | public void loadStandardModules() {
43 | super.loadStandardModules();
44 | // load two packages for the language module
45 | Module languageModule = modules.getLanguageModule();
46 | findOrCreatePackage(languageModule, AbstractModelLoader.CEYLON_LANGUAGE);
47 | findOrCreatePackage(languageModule, AbstractModelLoader.CEYLON_LANGUAGE_MODEL);
48 | findOrCreatePackage(languageModule, AbstractModelLoader.CEYLON_LANGUAGE_MODEL_DECLARATION);
49 | findOrCreatePackage(languageModule, AbstractModelLoader.CEYLON_LANGUAGE_SERIALIZATION);
50 | }
51 |
52 | @Override
53 | public boolean loadPackage(Module module, String packageName, boolean loadDeclarations) {
54 | // abort if we already loaded it, but only record that we loaded it if we want
55 | // to load the declarations, because merely calling complete() on the package
56 | // is OK
57 | packageName = JVMModuleUtil.quoteJavaKeywords(packageName);
58 | if(loadDeclarations && !loadedPackages.add(cacheKeyByModule(module, packageName))){
59 | return true;
60 | }
61 | if(!packageExists(module, packageName))
62 | return false;
63 | if(loadDeclarations){
64 | for(String file : getPackageList(module, packageName)){
65 | // ignore non-class stuff
66 | if(!file.toLowerCase().endsWith(".class"))
67 | continue;
68 | // turn it into a class name
69 | // FIXME: this is terrible
70 | String className = file.substring(0, file.length()-6).replace('/', '.');
71 | // get the last part
72 | int lastDot = className.lastIndexOf('.');
73 | String lastPart = lastDot == -1 ? className : className.substring(lastDot+1);
74 | int dollar = lastPart.indexOf('$');
75 | // if we have a dollar after the first char (where it would be quoting), skip it
76 | // because those are local/member/anonymous/impl ones
77 | if(dollar > 0)
78 | continue;
79 | // skip module/package declarations too (do not strip before checking)
80 | if(isModuleOrPackageDescriptorName(lastPart))
81 | continue;
82 |
83 | // the logic for lower-cased names should be abstracted somewhere sane
84 | if(!isLoadedFromSource(className)
85 | && (!className.endsWith("_") || !isLoadedFromSource(className.substring(0, className.length()-1)))
86 | && !isTypeHidden(module, className))
87 | convertToDeclaration(module, className, DeclarationType.TYPE);
88 | }
89 | if(module.getNameAsString().equals(JAVA_BASE_MODULE_NAME)
90 | && packageName.equals("java.lang"))
91 | loadJavaBaseArrays();
92 | }
93 | return true;
94 | }
95 |
96 | protected boolean isLoadedFromSource(String className) {
97 | return false;
98 | }
99 |
100 | @Override
101 | public ClassMirror lookupNewClassMirror(Module module, String name) {
102 | Class klass = null;
103 | // first try with the same name, for Java interop with classes with lowercase name
104 | klass = loadClass(module, JVMModuleUtil.quoteJavaKeywords(name));
105 | if (klass == null && lastPartHasLowerInitial(name) && !name.endsWith("_")) {
106 | klass = loadClass(module, JVMModuleUtil.quoteJavaKeywords(name+"_"));
107 | }
108 | return klass != null ? new ReflectionClass(klass) : null;
109 | }
110 |
111 | @Override
112 | protected String assembleJavaClass(String javaClass, String packageName) {
113 | // strip the java class name of its package part
114 | if(!packageName.isEmpty())
115 | javaClass = javaClass.substring(packageName.length()+1); // pkg + dot
116 | // now replace every dot in the name part with $
117 | javaClass = javaClass.replace('.', '$');
118 | // assemble back
119 | if(packageName.isEmpty())
120 | return javaClass;
121 | return packageName + "." + javaClass;
122 | }
123 |
124 | @Override
125 | protected boolean isOverridingMethod(MethodMirror methodSymbol) {
126 | final Member method = ((ReflectionMethod)methodSymbol).method;
127 | if (method.getDeclaringClass().getName().contentEquals("ceylon.language.Identifiable")) {
128 | if (method.getName().contentEquals("equals") || method.getName().contentEquals("hashCode")) {
129 | return true;
130 | }
131 | }
132 | if (method.getDeclaringClass().getName().contentEquals("ceylon.language.Object")) {
133 | if (method.getName().contentEquals("equals") || method.getName().contentEquals("hashCode") || method.getName().contentEquals("toString")) {
134 | return false;
135 | }
136 | }
137 | return ((ReflectionMethod)methodSymbol).isOverridingMethod();
138 | }
139 |
140 | @Override
141 | protected boolean isOverloadingMethod(MethodMirror methodSymbol) {
142 | return ((ReflectionMethod)methodSymbol).isOverloadingMethod();
143 | }
144 |
145 | @Override
146 | protected void logError(String message) {
147 | log.error(message);
148 | }
149 |
150 | @Override
151 | protected void logWarning(String message) {
152 | log.warning(message);
153 | }
154 |
155 | @Override
156 | protected void logVerbose(String message) {
157 | log.debug(message);
158 | }
159 |
160 | }
161 |
--------------------------------------------------------------------------------
/src/com/redhat/ceylon/model/loader/impl/reflect/mirror/ReflectionAnnotation.java:
--------------------------------------------------------------------------------
1 | package com.redhat.ceylon.model.loader.impl.reflect.mirror;
2 |
3 | import java.lang.annotation.Annotation;
4 | import java.lang.reflect.Method;
5 | import java.util.ArrayList;
6 | import java.util.List;
7 |
8 | import com.redhat.ceylon.model.loader.mirror.AnnotationMirror;
9 |
10 | public class ReflectionAnnotation implements AnnotationMirror {
11 |
12 | private Annotation annotation;
13 |
14 | public ReflectionAnnotation(Annotation annotation) {
15 | this.annotation = annotation;
16 | }
17 |
18 | @Override
19 | public Object getValue(String fieldName) {
20 | try {
21 | Method method = annotation.getClass().getMethod(fieldName);
22 | return convertValue(method.invoke(annotation));
23 | } catch (Exception e) {
24 | e.printStackTrace();
25 | return null;
26 | }
27 | }
28 |
29 | private Object convertValue(Object value) {
30 | Class valueClass = value.getClass();
31 | if(valueClass.isArray()){
32 | if (valueClass.getComponentType().isPrimitive()) {
33 | Class componentType = valueClass.getComponentType();
34 | if (componentType == short.class) {
35 | short[] array = (short[])value;
36 | List