← Back to branch summary

~ubuntu-branches/ubuntu/wily/aspectj/wily-proposed

« back to all changes in this revision

Viewing changes to org.aspectj/modules/org.aspectj.ajdt.core/src/org/aspectj/org/eclipse/jdt/core/dom/AjASTConverter.java

  • Committer: Bazaar Package Importer
  • Author(s): Damien Raude-Morvan
  • Date: 2011-03-15 23:54:31 UTC
  • mfrom: (1.2.5 upstream)
  • mto: This revision was merged to the branch mainline in revision 9.
  • Revision ID: james.westby@ubuntu.com-20110315235431-iq2gxbsx08kpwuiw
* New upstream release.
* Updated Standards-Version to 3.9.1 (no changes needed).
* Fix local Javadoc links:
  - d/patches/07_javadoc_links.diff: Use locally installed
   javadoc packages and hyperlink with them.
  - d/control: Add B-D on default-java-doc and libasm3-java-doc.
* d/control: Drop B-D on itself (our new bootstrap infrastructure doesn't need
  that anymore).
* Split packages into :
  - aspectj: only contains CLI tools.
  - libaspectj-java: JAR librairies for /usr/share/java.
  - libaspectj-java-doc: 4 API's Javadoc.
  - aspectj-doc: Programming Guides and SDK Documentation.

Show diffs side-by-side

added added

removed removed

Lines of Context:
org.aspectj/modules/org.aspectj.ajdt.core/src/org/aspectj/org/eclipse/jdt/core/dom/AjASTConverter.java
1
1
/*******************************************************************************
2
 
 * Copyright (c) 2000, 2005 IBM Corporation and others.
 
2
 * Copyright (c) 2000, 2010 IBM Corporation and others.
3
3
 * All rights reserved. This program and the accompanying materials
4
4
 * are made available under the terms of the Eclipse Public License v1.0
5
5
 * which accompanies this distribution, and is available at
7
7
 *
8
8
 * Contributors:
9
9
 *     IBM Corporation - initial API and implementation
 
10
 *     Nieraj Singh
10
11
 *******************************************************************************/
11
12
 
12
13
package org.aspectj.org.eclipse.jdt.core.dom;
400
401
                                declareDeclaration = new DeclareAtTypeDeclaration(this.ast);
401
402
                                ((DeclareAtTypeDeclaration) declareDeclaration).setPatternNode(convert(da.getTypePattern()));
402
403
                                SimpleName annotationName = new SimpleName(this.ast);
 
404
                                annotationName.setSourceRange(da.getAnnotationSourceStart(),
 
405
                                                da.getAnnotationSourceEnd() - da.getAnnotationSourceStart());
403
406
                                annotationName.internalSetIdentifier(da.getAnnotationString());
404
407
                                ((DeclareAtTypeDeclaration) declareDeclaration).setAnnotationName(annotationName);
405
408
                        } else if (da.getKind().equals(DeclareAnnotation.AT_CONSTRUCTOR)) {
406
409
                                declareDeclaration = new DeclareAtConstructorDeclaration(this.ast);
407
 
                                ((DeclareAtConstructorDeclaration) declareDeclaration).setPatternNode(convert(da.getSignaturePattern()));
 
410
                                ((DeclareAtConstructorDeclaration) declareDeclaration).setPatternNode(convertSignature(da.getSignaturePattern()));
408
411
                                SimpleName annotationName = new SimpleName(this.ast);
 
412
                                annotationName.setSourceRange(da.getAnnotationSourceStart(),
 
413
                                                da.getAnnotationSourceEnd() - da.getAnnotationSourceStart());
409
414
                                annotationName.internalSetIdentifier(da.getAnnotationString());
410
415
                                ((DeclareAtConstructorDeclaration) declareDeclaration).setAnnotationName(annotationName);
411
416
                        } else if (da.getKind().equals(DeclareAnnotation.AT_FIELD)) {
412
417
                                declareDeclaration = new DeclareAtFieldDeclaration(this.ast);
413
 
                                ((DeclareAtFieldDeclaration) declareDeclaration).setPatternNode(convert(da.getSignaturePattern()));
 
418
                                ((DeclareAtFieldDeclaration) declareDeclaration).setPatternNode(convertSignature(da.getSignaturePattern()));
414
419
                                SimpleName annotationName = new SimpleName(this.ast);
 
420
                                annotationName.setSourceRange(da.getAnnotationSourceStart(),
 
421
                                                da.getAnnotationSourceEnd() - da.getAnnotationSourceStart());
415
422
                                annotationName.internalSetIdentifier(da.getAnnotationString());
416
423
                                ((DeclareAtFieldDeclaration) declareDeclaration).setAnnotationName(annotationName);
417
424
                        } else if (da.getKind().equals(DeclareAnnotation.AT_METHOD)) {
418
425
                                declareDeclaration = new DeclareAtMethodDeclaration(this.ast);
419
 
                                ((DeclareAtMethodDeclaration) declareDeclaration).setPatternNode(convert(da.getSignaturePattern()));
 
426
                                ((DeclareAtMethodDeclaration) declareDeclaration).setPatternNode(convertSignature(da.getSignaturePattern()));
420
427
                                SimpleName annotationName = new SimpleName(this.ast);
 
428
                                annotationName.setSourceRange(da.getAnnotationSourceStart(),
 
429
                                                da.getAnnotationSourceEnd() - da.getAnnotationSourceStart());
421
430
                                annotationName.internalSetIdentifier(da.getAnnotationString());
422
431
                                ((DeclareAtMethodDeclaration) declareDeclaration).setAnnotationName(annotationName);
423
432
                        }
467
476
                                                .setTypePattern((org.aspectj.org.eclipse.jdt.core.dom.TypePattern) pNode);
468
477
                        }
469
478
                }
470
 
                declareDeclaration.setSourceRange(declareDecl.declarationSourceStart, declareDecl.declarationSourceEnd
471
 
                                - declareDecl.declarationSourceStart + 1);
 
479
                
 
480
                if (declareDeclaration != null) {
 
481
                        declareDeclaration.setSourceRange(declareDecl.declarationSourceStart, declareDecl.declarationSourceEnd
 
482
                                        - declareDecl.declarationSourceStart + 1);
 
483
                }
472
484
                return declareDeclaration;
473
485
        }
474
486
 
616
628
                return pointcutDesi;
617
629
        }
618
630
 
619
 
        public org.aspectj.org.eclipse.jdt.core.dom.PatternNode convert(ISignaturePattern patternNode) {
620
 
                org.aspectj.org.eclipse.jdt.core.dom.PatternNode pNode = null;
 
631
        public org.aspectj.org.eclipse.jdt.core.dom.SignaturePattern convertSignature(ISignaturePattern patternNode) {
 
632
                org.aspectj.org.eclipse.jdt.core.dom.SignaturePattern pNode = null;
621
633
                if (patternNode instanceof SignaturePattern) {
622
634
                        SignaturePattern sigPat = (SignaturePattern) patternNode;
623
635
                        pNode = new org.aspectj.org.eclipse.jdt.core.dom.SignaturePattern(this.ast, sigPat.toString());
628
640
                return pNode;
629
641
        }
630
642
 
631
 
        public org.aspectj.org.eclipse.jdt.core.dom.PatternNode convert(PatternNode patternNode) {
632
 
                // this is a stub to be used until dom classes have been created for
633
 
                // the different weaver TypePattern's
 
643
        public org.aspectj.org.eclipse.jdt.core.dom.PatternNode convert(
 
644
                        PatternNode patternNode) {
634
645
                org.aspectj.org.eclipse.jdt.core.dom.PatternNode pNode = null;
635
646
                if (patternNode instanceof TypePattern) {
636
 
                        TypePattern typePat = (TypePattern) patternNode;
637
 
                        pNode = new DefaultTypePattern(this.ast, typePat.toString());
638
 
                        pNode.setSourceRange(typePat.getStart(), (typePat.getEnd() - typePat.getStart() + 1));
 
647
                        TypePattern weaverTypePattern = (TypePattern) patternNode;
 
648
                        return convert(weaverTypePattern);
 
649
 
639
650
                } else if (patternNode instanceof SignaturePattern) {
640
651
                        SignaturePattern sigPat = (SignaturePattern) patternNode;
641
652
                        pNode = new org.aspectj.org.eclipse.jdt.core.dom.SignaturePattern(this.ast, sigPat.toString());
645
656
 
646
657
        }
647
658
 
 
659
        public org.aspectj.org.eclipse.jdt.core.dom.TypePattern convert(
 
660
                        TypePattern weaverNode) {
 
661
 
 
662
                // First check if the node is a Java type (WildType, ExactType,
 
663
                // BindingType)
 
664
                org.aspectj.org.eclipse.jdt.core.dom.TypePattern domNode = createIdentifierTypePattern(weaverNode);
 
665
 
 
666
                if (domNode == null) {
 
667
                        if (weaverNode instanceof org.aspectj.weaver.patterns.EllipsisTypePattern) {
 
668
                                domNode = new org.aspectj.org.eclipse.jdt.core.dom.EllipsisTypePattern(
 
669
                                                ast);
 
670
                        } else if (weaverNode instanceof org.aspectj.weaver.patterns.NoTypePattern) {
 
671
                                domNode = new org.aspectj.org.eclipse.jdt.core.dom.NoTypePattern(
 
672
                                                ast);
 
673
                        } else if (weaverNode instanceof org.aspectj.weaver.patterns.AnyTypePattern) {
 
674
                                domNode = new org.aspectj.org.eclipse.jdt.core.dom.AnyTypePattern(
 
675
                                                ast);
 
676
                        } else if (weaverNode instanceof org.aspectj.weaver.patterns.AnyWithAnnotationTypePattern) {
 
677
                                // For now construct the node with just the annotation
 
678
                                // expression
 
679
                                String annotationExpression = ((org.aspectj.weaver.patterns.AnyWithAnnotationTypePattern) weaverNode)
 
680
                                                .toString();
 
681
                                domNode = new org.aspectj.org.eclipse.jdt.core.dom.AnyWithAnnotationTypePattern(
 
682
                                                ast, annotationExpression);
 
683
 
 
684
                        } else if (weaverNode instanceof org.aspectj.weaver.patterns.OrTypePattern) {
 
685
                                org.aspectj.weaver.patterns.OrTypePattern compilerOrNode = (org.aspectj.weaver.patterns.OrTypePattern) weaverNode;
 
686
                                domNode = new OrTypePattern(this.ast,
 
687
                                                convert(compilerOrNode.getLeft()),
 
688
                                                convert(compilerOrNode.getRight()));
 
689
                        } else if (weaverNode instanceof org.aspectj.weaver.patterns.AndTypePattern) {
 
690
                                org.aspectj.weaver.patterns.AndTypePattern compilerAndType = (org.aspectj.weaver.patterns.AndTypePattern) weaverNode;
 
691
                                domNode = new org.aspectj.org.eclipse.jdt.core.dom.AndTypePattern(
 
692
                                                this.ast, convert(compilerAndType.getLeft()),
 
693
                                                convert(compilerAndType.getRight()));
 
694
                        } else if (weaverNode instanceof org.aspectj.weaver.patterns.NotTypePattern) {
 
695
                                //NOTE: the source range for not type patterns is the source range of the negated type pattern
 
696
                                // EXCLUDING the "!" character. Example: !A. If A starts at 1, the source starting point for the
 
697
                                // nottypepattern is 1, NOT 0.
 
698
                                TypePattern negatedTypePattern = ((org.aspectj.weaver.patterns.NotTypePattern) weaverNode)
 
699
                                                .getNegatedPattern();
 
700
                                org.aspectj.org.eclipse.jdt.core.dom.TypePattern negatedDomTypePattern = convert(negatedTypePattern);
 
701
                                domNode = new org.aspectj.org.eclipse.jdt.core.dom.NotTypePattern(
 
702
                                                ast, negatedDomTypePattern);
 
703
                        } else if (weaverNode instanceof org.aspectj.weaver.patterns.TypeCategoryTypePattern) {
 
704
                                org.aspectj.weaver.patterns.TypeCategoryTypePattern typeCategoryWeaverNode = (org.aspectj.weaver.patterns.TypeCategoryTypePattern) weaverNode;
 
705
                                domNode = new org.aspectj.org.eclipse.jdt.core.dom.TypeCategoryTypePattern(
 
706
                                                ast, typeCategoryWeaverNode.getTypeCategory());
 
707
 
 
708
                        } else if (weaverNode instanceof org.aspectj.weaver.patterns.HasMemberTypePattern) {
 
709
                                ISignaturePattern weaverSignature = ((org.aspectj.weaver.patterns.HasMemberTypePattern) weaverNode)
 
710
                                                .getSignaturePattern();
 
711
                                org.aspectj.org.eclipse.jdt.core.dom.SignaturePattern signature = convertSignature(weaverSignature);
 
712
                                domNode = new org.aspectj.org.eclipse.jdt.core.dom.HasMemberTypePattern(
 
713
                                                ast, signature);
 
714
                        } else {
 
715
                                // Handle any cases that are not yet implemented. Create a
 
716
                                // default node for
 
717
                                // them.
 
718
                                domNode = new DefaultTypePattern(this.ast,
 
719
                                                weaverNode.toString());
 
720
                        }
 
721
                }
 
722
 
 
723
                if (domNode != null) {
 
724
                        domNode.setSourceRange(weaverNode.getStart(), (weaverNode.getEnd()
 
725
                                        - weaverNode.getStart() + 1));
 
726
                }
 
727
                return domNode;
 
728
        }
 
729
 
 
730
        /**
 
731
         * Creates an ExactType, WildType, or BindingType, or null if none of the
 
732
         * three can be created
 
733
         * 
 
734
         * @param weaverTypePattern
 
735
         *            to convert to a DOM equivalent
 
736
         * @return DOM node or null if it was not created
 
737
         */
 
738
        protected org.aspectj.org.eclipse.jdt.core.dom.TypePattern createIdentifierTypePattern(
 
739
                        TypePattern weaverTypePattern) {
 
740
                String typeExpression = weaverTypePattern.toString();
 
741
 
 
742
                org.aspectj.org.eclipse.jdt.core.dom.TypePattern domTypePattern = null;
 
743
                if (weaverTypePattern instanceof org.aspectj.weaver.patterns.WildTypePattern) {
 
744
                        // Use the expression for wild type patterns as a Name may not be
 
745
                        // constructed
 
746
                        // for a Type with a unresolved typeExpression
 
747
                        domTypePattern = new org.aspectj.org.eclipse.jdt.core.dom.WildTypePattern(
 
748
                                        ast, typeExpression);
 
749
                } else {
 
750
                        // TODO: At this point, the type pattern should be resolved. Type
 
751
                        // information
 
752
                        // may be able to be obtained from the exact type in the weaver
 
753
                        // pattern, therefore
 
754
                        // replace using the expression to construct the Type and use more
 
755
                        // appropriate
 
756
                        // information obtained from the exact type
 
757
 
 
758
                        if (weaverTypePattern instanceof org.aspectj.weaver.patterns.ExactTypePattern) {
 
759
                                Type type = this.ast.newSimpleType(this.ast
 
760
                                                .newSimpleName(typeExpression));
 
761
                                domTypePattern = new ExactTypePattern(ast, type);
 
762
                        } else if (weaverTypePattern instanceof org.aspectj.weaver.patterns.BindingTypePattern) {
 
763
                                Type type = this.ast.newSimpleType(this.ast
 
764
                                                .newSimpleName(typeExpression));
 
765
                                String binding = ((org.aspectj.weaver.patterns.BindingTypePattern) weaverTypePattern)
 
766
                                                .getBindingName();
 
767
                                FormalBinding formalBinding = new FormalBinding(type, binding,
 
768
                                                ast);
 
769
                                domTypePattern = new org.aspectj.org.eclipse.jdt.core.dom.BindingTypePattern(
 
770
                                                ast, formalBinding);
 
771
                        }
 
772
                }
 
773
                return domTypePattern;
 
774
        }
 
775
 
648
776
        public ASTNode convert(
649
777
                        org.aspectj.org.eclipse.jdt.internal.compiler.ast.AnnotationMethodDeclaration annotationTypeMemberDeclaration) {
650
778
                checkCanceled();
750
878
        // }
751
879
        // arrayCreation.setSourceRange(expression.sourceStart, expression.sourceEnd - expression.sourceStart + 1);
752
880
        // org.aspectj.org.eclipse.jdt.internal.compiler.ast.Expression[] dimensions = expression.dimensions;
753
 
        //              
 
881
        //
754
882
        // int dimensionsLength = dimensions.length;
755
883
        // for (int i = 0; i < dimensionsLength; i++) {
756
884
        // if (dimensions[i] != null) {
971
1099
        // case org.aspectj.org.eclipse.jdt.internal.compiler.ast.OperatorIds.LESS :
972
1100
        // infixExpression.setOperator(InfixExpression.Operator.LESS);
973
1101
        // }
974
 
        //              
 
1102
        //
975
1103
        // if (expression.left instanceof org.aspectj.org.eclipse.jdt.internal.compiler.ast.BinaryExpression
976
1104
        // && ((expression.left.bits & org.aspectj.org.eclipse.jdt.internal.compiler.ast.ASTNode.ParenthesizedMASK) == 0)) {
977
1105
        // // create an extended string literal equivalent => use the extended operands list
1000
1128
        // for (int i = 0; i < size - 1; i++) {
1001
1129
        // Expression expr = temp;
1002
1130
        // temp = new InfixExpression(this.ast);
1003
 
        //                                              
 
1131
        //
1004
1132
        // if (this.resolveBindings) {
1005
1133
        // this.recordNodes(temp, expression);
1006
1134
        // }
1559
1687
                                for (int i = 1; i < initializationsLength; i++) {
1560
1688
                                        variableDeclarationExpression
1561
1689
                                                        .fragments()
1562
 
                                                        .add(
1563
 
                                                                        convertToVariableDeclarationFragment((org.aspectj.org.eclipse.jdt.internal.compiler.ast.LocalDeclaration) initializations[i]));
 
1690
                                                        .add(convertToVariableDeclarationFragment((org.aspectj.org.eclipse.jdt.internal.compiler.ast.LocalDeclaration) initializations[i]));
1564
1691
                                }
1565
1692
                                if (initializationsLength != 1) {
1566
1693
                                        int start = variableDeclarationExpression.getStartPosition();
2178
2305
                if (typeDeclaration.modifiersSourceStart != -1) {
2179
2306
                        setModifiers(typeDecl, typeDeclaration);
2180
2307
                }
2181
 
                typeDecl
2182
 
                                .setInterface(org.aspectj.org.eclipse.jdt.internal.compiler.ast.TypeDeclaration.kind(typeDeclaration.modifiers) == org.aspectj.org.eclipse.jdt.internal.compiler.ast.TypeDeclaration.INTERFACE_DECL);
 
2308
                typeDecl.setInterface(org.aspectj.org.eclipse.jdt.internal.compiler.ast.TypeDeclaration.kind(typeDeclaration.modifiers) == org.aspectj.org.eclipse.jdt.internal.compiler.ast.TypeDeclaration.INTERFACE_DECL);
2183
2309
                final SimpleName typeName = new SimpleName(this.ast);
2184
2310
                typeName.internalSetIdentifier(new String(typeDeclaration.name));
2185
2311
                typeName.setSourceRange(typeDeclaration.sourceStart, typeDeclaration.sourceEnd - typeDeclaration.sourceStart + 1);
2350
2476
                variableDeclarationExpression.setSourceRange(localDeclaration.declarationSourceStart, localDeclaration.declarationSourceEnd
2351
2477
                                - localDeclaration.declarationSourceStart + 1);
2352
2478
                Type type = convertType(localDeclaration.type);
2353
 
                setTypeForVariableDeclarationExpression(variableDeclarationExpression, type, variableDeclarationFragment
2354
 
                                .getExtraDimensions());
 
2479
                setTypeForVariableDeclarationExpression(variableDeclarationExpression, type,
 
2480
                                variableDeclarationFragment.getExtraDimensions());
2355
2481
                if (localDeclaration.modifiersSourceStart != -1) {
2356
2482
                        setModifiers(variableDeclarationExpression, localDeclaration);
2357
2483
                }