1
2
3
4 package net.sourceforge.pmd.lang.java.typeresolution;
5
6 import java.util.ArrayList;
7 import java.util.Collections;
8 import java.util.HashMap;
9 import java.util.List;
10 import java.util.Map;
11 import java.util.logging.Level;
12 import java.util.logging.Logger;
13
14 import net.sourceforge.pmd.lang.ast.AbstractNode;
15 import net.sourceforge.pmd.lang.ast.Node;
16 import net.sourceforge.pmd.lang.java.ast.ASTAdditiveExpression;
17 import net.sourceforge.pmd.lang.java.ast.ASTAllocationExpression;
18 import net.sourceforge.pmd.lang.java.ast.ASTAndExpression;
19 import net.sourceforge.pmd.lang.java.ast.ASTAnnotationTypeDeclaration;
20 import net.sourceforge.pmd.lang.java.ast.ASTArrayDimsAndInits;
21 import net.sourceforge.pmd.lang.java.ast.ASTBooleanLiteral;
22 import net.sourceforge.pmd.lang.java.ast.ASTCastExpression;
23 import net.sourceforge.pmd.lang.java.ast.ASTClassOrInterfaceBody;
24 import net.sourceforge.pmd.lang.java.ast.ASTClassOrInterfaceDeclaration;
25 import net.sourceforge.pmd.lang.java.ast.ASTClassOrInterfaceType;
26 import net.sourceforge.pmd.lang.java.ast.ASTCompilationUnit;
27 import net.sourceforge.pmd.lang.java.ast.ASTConditionalAndExpression;
28 import net.sourceforge.pmd.lang.java.ast.ASTConditionalExpression;
29 import net.sourceforge.pmd.lang.java.ast.ASTConditionalOrExpression;
30 import net.sourceforge.pmd.lang.java.ast.ASTEnumDeclaration;
31 import net.sourceforge.pmd.lang.java.ast.ASTEqualityExpression;
32 import net.sourceforge.pmd.lang.java.ast.ASTExclusiveOrExpression;
33 import net.sourceforge.pmd.lang.java.ast.ASTExpression;
34 import net.sourceforge.pmd.lang.java.ast.ASTFieldDeclaration;
35 import net.sourceforge.pmd.lang.java.ast.ASTImportDeclaration;
36 import net.sourceforge.pmd.lang.java.ast.ASTInclusiveOrExpression;
37 import net.sourceforge.pmd.lang.java.ast.ASTInstanceOfExpression;
38 import net.sourceforge.pmd.lang.java.ast.ASTLiteral;
39 import net.sourceforge.pmd.lang.java.ast.ASTMarkerAnnotation;
40 import net.sourceforge.pmd.lang.java.ast.ASTMultiplicativeExpression;
41 import net.sourceforge.pmd.lang.java.ast.ASTName;
42 import net.sourceforge.pmd.lang.java.ast.ASTNormalAnnotation;
43 import net.sourceforge.pmd.lang.java.ast.ASTNullLiteral;
44 import net.sourceforge.pmd.lang.java.ast.ASTPackageDeclaration;
45 import net.sourceforge.pmd.lang.java.ast.ASTPostfixExpression;
46 import net.sourceforge.pmd.lang.java.ast.ASTPreDecrementExpression;
47 import net.sourceforge.pmd.lang.java.ast.ASTPreIncrementExpression;
48 import net.sourceforge.pmd.lang.java.ast.ASTPrimaryExpression;
49 import net.sourceforge.pmd.lang.java.ast.ASTPrimaryPrefix;
50 import net.sourceforge.pmd.lang.java.ast.ASTPrimarySuffix;
51 import net.sourceforge.pmd.lang.java.ast.ASTPrimitiveType;
52 import net.sourceforge.pmd.lang.java.ast.ASTReferenceType;
53 import net.sourceforge.pmd.lang.java.ast.ASTRelationalExpression;
54 import net.sourceforge.pmd.lang.java.ast.ASTShiftExpression;
55 import net.sourceforge.pmd.lang.java.ast.ASTSingleMemberAnnotation;
56 import net.sourceforge.pmd.lang.java.ast.ASTStatementExpression;
57 import net.sourceforge.pmd.lang.java.ast.ASTType;
58 import net.sourceforge.pmd.lang.java.ast.ASTTypeDeclaration;
59 import net.sourceforge.pmd.lang.java.ast.ASTUnaryExpression;
60 import net.sourceforge.pmd.lang.java.ast.ASTUnaryExpressionNotPlusMinus;
61 import net.sourceforge.pmd.lang.java.ast.ASTVariableDeclarator;
62 import net.sourceforge.pmd.lang.java.ast.ASTVariableDeclaratorId;
63 import net.sourceforge.pmd.lang.java.ast.JavaParserVisitorAdapter;
64 import net.sourceforge.pmd.lang.java.ast.TypeNode;
65
66
67
68
69
70
71
72 public class ClassTypeResolver extends JavaParserVisitorAdapter {
73
74 private static final Logger LOG = Logger.getLogger(ClassTypeResolver.class.getName());
75
76 private static final Map<String, Class<?>> PRIMITIVE_TYPES;
77 private static final Map<String, String> JAVA_LANG;
78
79 static {
80
81 Map<String, Class<?>> thePrimitiveTypes = new HashMap<String, Class<?>>();
82 thePrimitiveTypes.put("void", Void.TYPE);
83 thePrimitiveTypes.put("boolean", Boolean.TYPE);
84 thePrimitiveTypes.put("byte", Byte.TYPE);
85 thePrimitiveTypes.put("char", Character.TYPE);
86 thePrimitiveTypes.put("short", Short.TYPE);
87 thePrimitiveTypes.put("int", Integer.TYPE);
88 thePrimitiveTypes.put("long", Long.TYPE);
89 thePrimitiveTypes.put("float", Float.TYPE);
90 thePrimitiveTypes.put("double", Double.TYPE);
91 PRIMITIVE_TYPES = Collections.unmodifiableMap(thePrimitiveTypes);
92
93 Map<String, String> theJavaLang = new HashMap<String, String>();
94 theJavaLang.put("Boolean", "java.lang.Boolean");
95 theJavaLang.put("Byte", "java.lang.Byte");
96 theJavaLang.put("Character", "java.lang.Character");
97 theJavaLang.put("CharSequence", "java.lang.CharSequence");
98 theJavaLang.put("Class", "java.lang.Class");
99 theJavaLang.put("ClassLoader", "java.lang.ClassLoader");
100 theJavaLang.put("Cloneable", "java.lang.Cloneable");
101 theJavaLang.put("Comparable", "java.lang.Comparable");
102 theJavaLang.put("Compiler", "java.lang.Compiler");
103 theJavaLang.put("Double", "java.lang.Double");
104 theJavaLang.put("Float", "java.lang.Float");
105 theJavaLang.put("InheritableThreadLocal", "java.lang.InheritableThreadLocal");
106 theJavaLang.put("Integer", "java.lang.Integer");
107 theJavaLang.put("Long", "java.lang.Long");
108 theJavaLang.put("Math", "java.lang.Math");
109 theJavaLang.put("Number", "java.lang.Number");
110 theJavaLang.put("Object", "java.lang.Object");
111 theJavaLang.put("Package", "java.lang.Package");
112 theJavaLang.put("Process", "java.lang.Process");
113 theJavaLang.put("Runnable", "java.lang.Runnable");
114 theJavaLang.put("Runtime", "java.lang.Runtime");
115 theJavaLang.put("RuntimePermission", "java.lang.RuntimePermission");
116 theJavaLang.put("SecurityManager", "java.lang.SecurityManager");
117 theJavaLang.put("Short", "java.lang.Short");
118 theJavaLang.put("StackTraceElement", "java.lang.StackTraceElement");
119 theJavaLang.put("StrictMath", "java.lang.StrictMath");
120 theJavaLang.put("String", "java.lang.String");
121 theJavaLang.put("StringBuffer", "java.lang.StringBuffer");
122 theJavaLang.put("System", "java.lang.System");
123 theJavaLang.put("Thread", "java.lang.Thread");
124 theJavaLang.put("ThreadGroup", "java.lang.ThreadGroup");
125 theJavaLang.put("ThreadLocal", "java.lang.ThreadLocal");
126 theJavaLang.put("Throwable", "java.lang.Throwable");
127 theJavaLang.put("Void", "java.lang.Void");
128 JAVA_LANG = Collections.unmodifiableMap(theJavaLang);
129 }
130
131 private final PMDASMClassLoader pmdClassLoader;
132 private Map<String, String> importedClasses;
133 private List<String> importedOnDemand;
134 private int anonymousClassCounter = 0;
135
136 public ClassTypeResolver() {
137 this(ClassTypeResolver.class.getClassLoader());
138 }
139
140 public ClassTypeResolver(ClassLoader classLoader) {
141 pmdClassLoader = PMDASMClassLoader.getInstance(classLoader);
142 }
143
144
145 @Override
146 public Object visit(ASTCompilationUnit node, Object data) {
147 String className = null;
148 try {
149 importedOnDemand = new ArrayList<String>();
150 importedClasses = new HashMap<String, String>();
151 className = getClassName(node);
152 if (className != null) {
153 populateClassName(node, className);
154 }
155 } catch (ClassNotFoundException e) {
156 LOG.log(Level.FINE, "Could not find class " + className + ", due to: " + e.getClass().getName() + ": " + e.getMessage());
157 } catch (LinkageError e) {
158 LOG.log(Level.WARNING, "Could not find class " + className + ", due to: " + e.getClass().getName() + ": " + e.getMessage());
159 } finally {
160 populateImports(node);
161 }
162 return super.visit(node, data);
163 }
164
165 @Override
166 public Object visit(ASTImportDeclaration node, Object data) {
167 ASTName importedType = (ASTName)node.jjtGetChild(0);
168 if (importedType.getType() != null) {
169 node.setType(importedType.getType());
170 } else {
171 populateType(node, importedType.getImage());
172 }
173
174 if (node.getType() != null) {
175 node.setPackage(node.getType().getPackage());
176 }
177 return data;
178 }
179
180 @Override
181 public Object visit(ASTTypeDeclaration node, Object data) {
182 super.visit(node, data);
183 rollupTypeUnary(node);
184 return data;
185 }
186
187 @Override
188 public Object visit(ASTClassOrInterfaceType node, Object data) {
189 String typeName = node.getImage();
190 if (node.jjtGetParent().hasDescendantOfType(ASTClassOrInterfaceBody.class)) {
191 anonymousClassCounter++;
192 AbstractNode parent = node.getFirstParentOfType(ASTClassOrInterfaceDeclaration.class);
193 if (parent == null) {
194 parent = node.getFirstParentOfType(ASTEnumDeclaration.class);
195 }
196 typeName = parent.getImage() + "$" + anonymousClassCounter;
197 }
198 populateType(node, typeName);
199 return data;
200 }
201
202 @Override
203 public Object visit(ASTClassOrInterfaceDeclaration node, Object data) {
204 populateType(node, node.getImage());
205 return super.visit(node, data);
206 }
207
208 @Override
209 public Object visit(ASTEnumDeclaration node, Object data) {
210 populateType(node, node.getImage());
211 return super.visit(node, data);
212 }
213
214 @Override
215 public Object visit(ASTAnnotationTypeDeclaration node, Object data) {
216 populateType(node, node.getImage());
217 return super.visit(node, data);
218 }
219
220 @Override
221 public Object visit(ASTName node, Object data) {
222
223
224
225
226
227
228 if (node.getNameDeclaration() == null) {
229
230
231
232 if (!(node.jjtGetParent() instanceof ASTPackageDeclaration || node.jjtGetParent() instanceof ASTImportDeclaration)) {
233 String name = node.getImage();
234 if (name.indexOf('.') != -1) {
235 name = name.substring(0, name.indexOf('.'));
236 }
237 populateType(node, name);
238 }
239 } else {
240
241 if (node.getNameDeclaration().getNode() instanceof TypeNode) {
242 node.setType(((TypeNode)node.getNameDeclaration().getNode()).getType());
243 }
244 }
245 return super.visit(node, data);
246 }
247
248 @Override
249 public Object visit(ASTFieldDeclaration node, Object data) {
250 super.visit(node, data);
251 rollupTypeUnary(node);
252 return data;
253 }
254
255 @Override
256 public Object visit(ASTVariableDeclarator node, Object data) {
257 super.visit(node, data);
258 rollupTypeUnary(node);
259 return data;
260 }
261
262 @Override
263 public Object visit(ASTVariableDeclaratorId node, Object data) {
264 if (node == null || node.getNameDeclaration() == null) {
265 return super.visit(node, data);
266 }
267 String name = node.getNameDeclaration().getTypeImage();
268 if (name != null) {
269 if (name.indexOf('.') != -1) {
270 name = name.substring(0, name.indexOf('.'));
271 }
272 populateType(node, name);
273 }
274 return super.visit(node, data);
275 }
276
277 @Override
278 public Object visit(ASTType node, Object data) {
279 super.visit(node, data);
280 rollupTypeUnary(node);
281 return data;
282 }
283
284 @Override
285 public Object visit(ASTReferenceType node, Object data) {
286 super.visit(node, data);
287 rollupTypeUnary(node);
288 return data;
289 }
290
291 @Override
292 public Object visit(ASTPrimitiveType node, Object data) {
293 populateType(node, node.getImage());
294 return super.visit(node, data);
295 }
296
297 @Override
298 public Object visit(ASTExpression node, Object data) {
299 super.visit(node, data);
300 rollupTypeUnary(node);
301 return data;
302 }
303
304 @Override
305 public Object visit(ASTConditionalExpression node, Object data) {
306 super.visit(node, data);
307 if (node.isTernary()) {
308
309 } else {
310 rollupTypeUnary(node);
311 }
312 return data;
313 }
314
315 @Override
316 public Object visit(ASTConditionalOrExpression node, Object data) {
317 populateType(node, "boolean");
318 return super.visit(node, data);
319 }
320
321 @Override
322 public Object visit(ASTConditionalAndExpression node, Object data) {
323 populateType(node, "boolean");
324 return super.visit(node, data);
325 }
326
327 @Override
328 public Object visit(ASTInclusiveOrExpression node, Object data) {
329 super.visit(node, data);
330 rollupTypeBinaryNumericPromotion(node);
331 return data;
332 }
333
334 @Override
335 public Object visit(ASTExclusiveOrExpression node, Object data) {
336 super.visit(node, data);
337 rollupTypeBinaryNumericPromotion(node);
338 return data;
339 }
340
341 @Override
342 public Object visit(ASTAndExpression node, Object data) {
343 super.visit(node, data);
344 rollupTypeBinaryNumericPromotion(node);
345 return data;
346 }
347
348 @Override
349 public Object visit(ASTEqualityExpression node, Object data) {
350 populateType(node, "boolean");
351 return super.visit(node, data);
352 }
353
354 @Override
355 public Object visit(ASTInstanceOfExpression node, Object data) {
356 populateType(node, "boolean");
357 return super.visit(node, data);
358 }
359
360 @Override
361 public Object visit(ASTRelationalExpression node, Object data) {
362 populateType(node, "boolean");
363 return super.visit(node, data);
364 }
365
366 @Override
367 public Object visit(ASTShiftExpression node, Object data) {
368 super.visit(node, data);
369
370 rollupTypeUnaryNumericPromotion(node);
371 return data;
372 }
373
374 @Override
375 public Object visit(ASTAdditiveExpression node, Object data) {
376 super.visit(node, data);
377 rollupTypeBinaryNumericPromotion(node);
378 return data;
379 }
380
381 @Override
382 public Object visit(ASTMultiplicativeExpression node, Object data) {
383 super.visit(node, data);
384 rollupTypeBinaryNumericPromotion(node);
385 return data;
386 }
387
388 @Override
389 public Object visit(ASTUnaryExpression node, Object data) {
390 super.visit(node, data);
391 rollupTypeUnaryNumericPromotion(node);
392 return data;
393 }
394
395 @Override
396 public Object visit(ASTPreIncrementExpression node, Object data) {
397 super.visit(node, data);
398 rollupTypeUnary(node);
399 return data;
400 }
401
402 @Override
403 public Object visit(ASTPreDecrementExpression node, Object data) {
404 super.visit(node, data);
405 rollupTypeUnary(node);
406 return data;
407 }
408
409 @Override
410 public Object visit(ASTUnaryExpressionNotPlusMinus node, Object data) {
411 super.visit(node, data);
412 if ("!".equals(node.getImage())) {
413 populateType(node, "boolean");
414 } else {
415 rollupTypeUnary(node);
416 }
417 return data;
418 }
419
420 @Override
421 public Object visit(ASTPostfixExpression node, Object data) {
422 super.visit(node, data);
423 rollupTypeUnary(node);
424 return data;
425 }
426
427 @Override
428 public Object visit(ASTCastExpression node, Object data) {
429 super.visit(node, data);
430 rollupTypeUnary(node);
431 return data;
432 }
433
434 @Override
435 public Object visit(ASTPrimaryExpression node, Object data) {
436 super.visit(node, data);
437 if (node.jjtGetNumChildren() == 1) {
438 rollupTypeUnary(node);
439 } else {
440
441 }
442 return data;
443 }
444
445 @Override
446 public Object visit(ASTPrimaryPrefix node, Object data) {
447 super.visit(node, data);
448 if (node.getImage() == null) {
449 rollupTypeUnary(node);
450 } else {
451
452 }
453 return data;
454 }
455
456 @Override
457 public Object visit(ASTPrimarySuffix node, Object data) {
458 super.visit(node, data);
459
460 return data;
461 }
462
463 @Override
464 public Object visit(ASTNullLiteral node, Object data) {
465
466 return super.visit(node, data);
467 }
468
469 @Override
470 public Object visit(ASTBooleanLiteral node, Object data) {
471 populateType(node, "boolean");
472 return super.visit(node, data);
473 }
474
475 @Override
476 public Object visit(ASTLiteral node, Object data) {
477 super.visit(node, data);
478 if (node.jjtGetNumChildren() != 0) {
479 rollupTypeUnary(node);
480 } else {
481 if (node.isIntLiteral()) {
482 populateType(node, "int");
483 } else if (node.isLongLiteral()) {
484 populateType(node, "long");
485 } else if (node.isFloatLiteral()) {
486 populateType(node, "float");
487 } else if (node.isDoubleLiteral()) {
488 populateType(node, "double");
489 } else if (node.isCharLiteral()) {
490 populateType(node, "char");
491 } else if (node.isStringLiteral()) {
492 populateType(node, "java.lang.String");
493 } else {
494 throw new IllegalStateException("PMD error, unknown literal type!");
495 }
496 }
497 return data;
498 }
499
500 @Override
501 public Object visit(ASTAllocationExpression node, Object data) {
502 super.visit(node, data);
503
504 if (node.jjtGetNumChildren() >= 2 && node.jjtGetChild(1) instanceof ASTArrayDimsAndInits
505 || node.jjtGetNumChildren() >= 3 && node.jjtGetChild(2) instanceof ASTArrayDimsAndInits) {
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524 } else {
525 rollupTypeUnary(node);
526 }
527 return data;
528 }
529
530 @Override
531 public Object visit(ASTStatementExpression node, Object data) {
532 super.visit(node, data);
533 rollupTypeUnary(node);
534 return data;
535 }
536
537 @Override
538 public Object visit(ASTNormalAnnotation node, Object data) {
539 super.visit(node, data);
540 rollupTypeUnary(node);
541 return data;
542 }
543
544 @Override
545 public Object visit(ASTMarkerAnnotation node, Object data) {
546 super.visit(node, data);
547 rollupTypeUnary(node);
548 return data;
549 }
550
551 @Override
552 public Object visit(ASTSingleMemberAnnotation node, Object data) {
553 super.visit(node, data);
554 rollupTypeUnary(node);
555 return data;
556 }
557
558
559 private void rollupTypeUnary(TypeNode typeNode) {
560 if (typeNode instanceof Node) {
561 Node node = (Node)typeNode;
562 if (node.jjtGetNumChildren() >= 1) {
563 Node child = node.jjtGetChild(0);
564 if (child instanceof TypeNode) {
565 typeNode.setType(((TypeNode)child).getType());
566 }
567 }
568 }
569 }
570
571
572 private void rollupTypeUnaryNumericPromotion(TypeNode typeNode) {
573 if (typeNode instanceof Node) {
574 Node node = (Node)typeNode;
575 if (node.jjtGetNumChildren() >= 1) {
576 Node child = node.jjtGetChild(0);
577 if (child instanceof TypeNode) {
578 Class<?> type = ((TypeNode)child).getType();
579 if (type != null) {
580 if ("byte".equals(type.getName()) || "short".equals(type.getName())
581 || "char".equals(type.getName())) {
582 populateType(typeNode, "int");
583 } else {
584 typeNode.setType(((TypeNode)child).getType());
585 }
586 }
587 }
588 }
589 }
590 }
591
592
593 private void rollupTypeBinaryNumericPromotion(TypeNode typeNode) {
594 if (typeNode instanceof Node) {
595 Node node = (Node)typeNode;
596 if (node.jjtGetNumChildren() >= 2) {
597 Node child1 = node.jjtGetChild(0);
598 Node child2 = node.jjtGetChild(1);
599 if (child1 instanceof TypeNode && child2 instanceof TypeNode) {
600 Class<?> type1 = ((TypeNode)child1).getType();
601 Class<?> type2 = ((TypeNode)child2).getType();
602 if (type1 != null && type2 != null) {
603
604 if ("java.lang.String".equals(type1.getName()) || "java.lang.String".equals(type2.getName())) {
605 populateType(typeNode, "java.lang.String");
606 } else if ("boolean".equals(type1.getName()) || "boolean".equals(type2.getName())) {
607 populateType(typeNode, "boolean");
608 } else if ("double".equals(type1.getName()) || "double".equals(type2.getName())) {
609 populateType(typeNode, "double");
610 } else if ("float".equals(type1.getName()) || "float".equals(type2.getName())) {
611 populateType(typeNode, "float");
612 } else if ("long".equals(type1.getName()) || "long".equals(type2.getName())) {
613 populateType(typeNode, "long");
614 } else {
615 populateType(typeNode, "int");
616 }
617 } else if (type1 != null || type2 != null) {
618
619
620 if (type1 != null && "java.lang.String".equals(type1.getName())
621 || type2 != null && "java.lang.String".equals(type2.getName())) {
622 populateType(typeNode, "java.lang.String");
623 }
624 }
625 }
626 }
627 }
628 }
629
630 private void populateType(TypeNode node, String className) {
631
632 String qualifiedName = className;
633 Class<?> myType = PRIMITIVE_TYPES.get(className);
634 if (myType == null && importedClasses != null) {
635 if (importedClasses.containsKey(className)) {
636 qualifiedName = importedClasses.get(className);
637 } else if (importedClasses.containsValue(className)) {
638 qualifiedName = className;
639 }
640 if (qualifiedName != null) {
641 try {
642
643
644
645
646
647 myType = pmdClassLoader.loadClass(qualifiedName);
648 } catch (ClassNotFoundException e) {
649 myType = processOnDemand(qualifiedName);
650 } catch (LinkageError e) {
651 myType = processOnDemand(qualifiedName);
652 }
653 }
654 }
655 if (myType == null && qualifiedName != null && !qualifiedName.contains(".")) {
656
657 try {
658 myType = pmdClassLoader.loadClass("java.lang." + qualifiedName);
659 } catch (Exception e) {
660
661 }
662 }
663 if (myType != null) {
664 node.setType(myType);
665 }
666 }
667
668
669
670
671 public boolean classNameExists(String fullyQualifiedClassName) {
672 try {
673 pmdClassLoader.loadClass(fullyQualifiedClassName);
674 return true;
675 } catch (ClassNotFoundException e) {
676 return false;
677 }
678 }
679
680 private Class<?> processOnDemand(String qualifiedName) {
681 for (String entry : importedOnDemand) {
682 try {
683 return pmdClassLoader.loadClass(entry + "." + qualifiedName);
684 } catch (Throwable e) {
685 }
686 }
687 return null;
688 }
689
690 private String getClassName(ASTCompilationUnit node) {
691 ASTClassOrInterfaceDeclaration classDecl = node.getFirstDescendantOfType(ASTClassOrInterfaceDeclaration.class);
692 if (classDecl == null) {
693 return null;
694 }
695 if (node.declarationsAreInDefaultPackage()) {
696 return classDecl.getImage();
697 }
698 ASTPackageDeclaration pkgDecl = node.getPackageDeclaration();
699 importedOnDemand.add(pkgDecl.getPackageNameImage());
700 return pkgDecl.getPackageNameImage() + "." + classDecl.getImage();
701 }
702
703
704
705
706
707
708 private void populateImports(ASTCompilationUnit node) {
709 List<ASTImportDeclaration> theImportDeclarations = node.findChildrenOfType(ASTImportDeclaration.class);
710
711 importedClasses.putAll(JAVA_LANG);
712
713
714 for (ASTImportDeclaration anImportDeclaration : theImportDeclarations) {
715 String strPackage = anImportDeclaration.getPackageName();
716 if (anImportDeclaration.isImportOnDemand()) {
717 importedOnDemand.add(strPackage);
718 } else if (!anImportDeclaration.isImportOnDemand()) {
719 String strName = anImportDeclaration.getImportedName();
720 importedClasses.put(strName, strName);
721 importedClasses.put(strName.substring(strPackage.length() + 1), strName);
722 }
723 }
724 }
725
726 private void populateClassName(ASTCompilationUnit node, String className) throws ClassNotFoundException {
727 node.setType(pmdClassLoader.loadClass(className));
728 importedClasses.putAll(pmdClassLoader.getImportedClasses(className));
729 }
730
731 }