001    /* This file was generated with JastAdd2 (http://jastadd.org) version 2.1.13-12-g880e696 */
002    package org.extendj.ast;
003    
004    import java.util.HashSet;
005    import java.io.File;
006    import java.util.Set;
007    import java.util.Collections;
008    import java.util.Collection;
009    import java.util.ArrayList;
010    import beaver.*;
011    import java.util.*;
012    import java.io.ByteArrayOutputStream;
013    import java.io.PrintStream;
014    import java.lang.reflect.InvocationTargetException;
015    import java.lang.reflect.Method;
016    import org.jastadd.util.*;
017    import java.util.zip.*;
018    import java.io.*;
019    import org.jastadd.util.PrettyPrintable;
020    import org.jastadd.util.PrettyPrinter;
021    import java.io.FileNotFoundException;
022    import java.io.BufferedInputStream;
023    import java.io.DataInputStream;
024    /**
025     * @ast node
026     * @declaredat /home/jesper/git/extendj/java4/grammar/Java.ast:16
027     * @production Dot : {@link AbstractDot};
028    
029     */
030    public class Dot extends AbstractDot implements Cloneable {
031      /**
032       * @aspect QualifiedNames
033       * @declaredat /home/jesper/git/extendj/java4/frontend/ResolveAmbiguousNames.jrag:125
034       */
035      public Dot lastDot() {
036        Dot node = this;
037        while (node.getRightNoTransform() instanceof Dot) {
038          node = (Dot) node.getRightNoTransform();
039        }
040        return node;
041      }
042      /**
043       * @aspect QualifiedNames
044       * @declaredat /home/jesper/git/extendj/java4/frontend/ResolveAmbiguousNames.jrag:143
045       */
046      public Dot qualifiesAccess(Access access) {
047        Dot lastDot = lastDot();
048        Expr l = lastDot.getRightNoTransform();
049        Dot dot = new Dot(lastDot.getRightNoTransform(), access);
050        dot.setStart(l.getStart());
051        dot.setEnd(access.getEnd());
052        lastDot.setRight(dot);
053        return this;
054      }
055      /**
056       * @aspect QualifiedNames
057       * @declaredat /home/jesper/git/extendj/java4/frontend/ResolveAmbiguousNames.jrag:154
058       */
059      private Access qualifyTailWith(Access expr) {
060        if (getRight/*NoTransform*/() instanceof AbstractDot) {
061          AbstractDot dot = (AbstractDot) getRight/*NoTransform*/();
062          return expr.qualifiesAccess(dot.getRight/*NoTransform*/());
063        }
064        return expr;
065      }
066      /**
067       * @aspect QualifiedNames
068       * @declaredat /home/jesper/git/extendj/java4/frontend/ResolveAmbiguousNames.jrag:173
069       */
070      public Access extractLast() {
071        return lastDot().getRightNoTransform();
072      }
073      /**
074       * @aspect QualifiedNames
075       * @declaredat /home/jesper/git/extendj/java4/frontend/ResolveAmbiguousNames.jrag:177
076       */
077      public void replaceLast(Access access) {
078        lastDot().setRight(access);
079      }
080      /**
081       * @declaredat ASTNode:1
082       */
083      public Dot() {
084        super();
085      }
086      /**
087       * Initializes the child array to the correct size.
088       * Initializes List and Opt nta children.
089       * @apilevel internal
090       * @ast method
091       * @declaredat ASTNode:10
092       */
093      public void init$Children() {
094        children = new ASTNode[2];
095      }
096      /**
097       * @declaredat ASTNode:13
098       */
099      public Dot(Expr p0, Access p1) {
100        setChild(p0, 0);
101        setChild(p1, 1);
102      }
103      /**
104       * @apilevel low-level
105       * @declaredat ASTNode:20
106       */
107      protected int numChildren() {
108        return 2;
109      }
110      /**
111       * @apilevel internal
112       * @declaredat ASTNode:26
113       */
114      public boolean mayHaveRewrite() {
115        return true;
116      }
117      /**
118       * @apilevel internal
119       * @declaredat ASTNode:32
120       */
121      public void flushAttrCache() {
122        super.flushAttrCache();
123      }
124      /**
125       * @apilevel internal
126       * @declaredat ASTNode:38
127       */
128      public void flushCollectionCache() {
129        super.flushCollectionCache();
130      }
131      /**
132       * @apilevel internal
133       * @declaredat ASTNode:44
134       */
135      public void flushRewriteCache() {
136        super.flushRewriteCache();
137      }
138      /**
139       * @apilevel internal
140       * @declaredat ASTNode:50
141       */
142      public Dot clone() throws CloneNotSupportedException {
143        Dot node = (Dot) super.clone();
144        return node;
145      }
146      /**
147       * @apilevel internal
148       * @declaredat ASTNode:57
149       */
150      public Dot copy() {
151        try {
152          Dot node = (Dot) clone();
153          node.parent = null;
154          if (children != null) {
155            node.children = (ASTNode[]) children.clone();
156          }
157          return node;
158        } catch (CloneNotSupportedException e) {
159          throw new Error("Error: clone not supported for " + getClass().getName());
160        }
161      }
162      /**
163       * Create a deep copy of the AST subtree at this node.
164       * The copy is dangling, i.e. has no parent.
165       * @return dangling copy of the subtree at this node
166       * @apilevel low-level
167       * @deprecated Please use treeCopy or treeCopyNoTransform instead
168       * @declaredat ASTNode:76
169       */
170      @Deprecated
171      public Dot fullCopy() {
172        return treeCopyNoTransform();
173      }
174      /**
175       * Create a deep copy of the AST subtree at this node.
176       * The copy is dangling, i.e. has no parent.
177       * @return dangling copy of the subtree at this node
178       * @apilevel low-level
179       * @declaredat ASTNode:86
180       */
181      public Dot treeCopyNoTransform() {
182        Dot tree = (Dot) copy();
183        if (children != null) {
184          for (int i = 0; i < children.length; ++i) {
185            ASTNode child = (ASTNode) children[i];
186            if (child != null) {
187              child = child.treeCopyNoTransform();
188              tree.setChild(child, i);
189            }
190          }
191        }
192        return tree;
193      }
194      /**
195       * Create a deep copy of the AST subtree at this node.
196       * The subtree of this node is traversed to trigger rewrites before copy.
197       * The copy is dangling, i.e. has no parent.
198       * @return dangling copy of the subtree at this node
199       * @apilevel low-level
200       * @declaredat ASTNode:106
201       */
202      public Dot treeCopy() {
203        doFullTraversal();
204        return treeCopyNoTransform();
205      }
206      /**
207       * @apilevel internal
208       * @declaredat ASTNode:113
209       */
210      protected boolean is$Equal(ASTNode node) {
211        return super.is$Equal(node);    
212      }
213      /**
214       * Replaces the Left child.
215       * @param node The new node to replace the Left child.
216       * @apilevel high-level
217       */
218      public void setLeft(Expr node) {
219        setChild(node, 0);
220      }
221      /**
222       * Retrieves the Left child.
223       * @return The current node used as the Left child.
224       * @apilevel high-level
225       */
226      @ASTNodeAnnotation.Child(name="Left")
227      public Expr getLeft() {
228        return (Expr) getChild(0);
229      }
230      /**
231       * Retrieves the Left child.
232       * <p><em>This method does not invoke AST transformations.</em></p>
233       * @return The current node used as the Left child.
234       * @apilevel low-level
235       */
236      public Expr getLeftNoTransform() {
237        return (Expr) getChildNoTransform(0);
238      }
239      /**
240       * Replaces the Right child.
241       * @param node The new node to replace the Right child.
242       * @apilevel high-level
243       */
244      public void setRight(Access node) {
245        setChild(node, 1);
246      }
247      /**
248       * Retrieves the Right child.
249       * @return The current node used as the Right child.
250       * @apilevel high-level
251       */
252      @ASTNodeAnnotation.Child(name="Right")
253      public Access getRight() {
254        return (Access) getChild(1);
255      }
256      /**
257       * Retrieves the Right child.
258       * <p><em>This method does not invoke AST transformations.</em></p>
259       * @return The current node used as the Right child.
260       * @apilevel low-level
261       */
262      public Access getRightNoTransform() {
263        return (Access) getChildNoTransform(1);
264      }
265      /**
266       * @apilevel internal
267       */
268      public ASTNode rewriteTo() {
269        // Declared at /home/jesper/git/extendj/java4/frontend/ResolveAmbiguousNames.jrag:243
270        if (leftSide().isPackageAccess() && rightSide().isPackageAccess()) {
271          return rewriteRule0();
272        }
273        // Declared at /home/jesper/git/extendj/java4/frontend/ResolveAmbiguousNames.jrag:253
274        if (leftSide().isPackageAccess() && !((Access) leftSide()).hasPrevExpr() && rightSide() instanceof TypeAccess) {
275          return rewriteRule1();
276        }
277        return super.rewriteTo();
278      }
279      /**
280       * @declaredat /home/jesper/git/extendj/java4/frontend/ResolveAmbiguousNames.jrag:243
281       * @apilevel internal
282       */
283      private Access rewriteRule0() {
284    {
285          PackageAccess left = (PackageAccess) leftSide();
286          PackageAccess right = (PackageAccess) rightSide();
287          left.setPackage(left.getPackage() + "." + right.getPackage());
288          left.setEnd(right.end());
289          return qualifyTailWith(left);
290        }  }
291      /**
292       * @declaredat /home/jesper/git/extendj/java4/frontend/ResolveAmbiguousNames.jrag:253
293       * @apilevel internal
294       */
295      private Access rewriteRule1() {
296    {
297          PackageAccess left = (PackageAccess) leftSide();
298          TypeAccess right = (TypeAccess) rightSide();
299          right.setPackage(left.getPackage());
300          right.setStart(left.start());
301          return qualifyTailWith(right);
302        }  }
303    }