2.4/dev/core/src/com/google/gwt/dev/jjs/ast/JModVisitor.java - gwt - Git at Google

 /*
  * Copyright 2008 Google Inc.
  *
  * 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.gwt.dev.jjs.ast;

 import com.google.gwt.dev.jjs.InternalCompilerException;
 import com.google.gwt.dev.util.collect.Lists;

 import java.util.List;

 /**
  * A visitor for iterating through and modifying an AST.
  */
 public class JModVisitor extends JVisitor {

   /**
    * Context for traversing a mutable list.
    */
   @SuppressWarnings("unchecked")
   private class ListContext<T extends JNode> implements Context {
     int index;
     final List<T> list;
     boolean removed;
     boolean replaced;

     public ListContext(List<T> list) {
       this.list = list;
     }

     public boolean canInsert() {
       return true;
     }

     public boolean canRemove() {
       return true;
     }

     public void insertAfter(JNode node) {
       checkRemoved();
       list.add(index + 1, (T) node);
       ++numVisitorChanges;
     }

     public void insertBefore(JNode node) {
       checkRemoved();
       list.add(index++, (T) node);
       ++numVisitorChanges;
     }

     public boolean isLvalue() {
       return false;
     }

     public void removeMe() {
       checkState();
       list.remove(index--);
       removed = true;
       ++numVisitorChanges;
     }

     public void replaceMe(JNode node) {
       checkState();
       checkReplacement(list.get(index), node);
       list.set(index, (T) node);
       replaced = true;
       ++numVisitorChanges;
     }

     /**
      * Cause my list to be traversed by this context.
      */
     protected List<T> traverse() {
       try {
         for (index = 0; index < list.size(); ++index) {
           removed = replaced = false;
           list.get(index).traverse(JModVisitor.this, this);
         }
         return list;
       } catch (Throwable e) {
         throw translateException(list.get(index), e);
       }
     }

     private void checkRemoved() {
       if (removed) {
         throw new InternalCompilerException("Node was already removed");
       }
     }

     private void checkState() {
       checkRemoved();
       if (replaced) {
         throw new InternalCompilerException("Node was already replaced");
       }
     }
   }

   /**
    * Context for traversing an immutable list.
    */
   @SuppressWarnings("unchecked")
   private class ListContextImmutable<T extends JNode> implements Context {
     int index;
     List<T> list;
     boolean removed;
     boolean replaced;

     public ListContextImmutable(List<T> list) {
       this.list = list;
     }

     public boolean canInsert() {
       return true;
     }

     public boolean canRemove() {
       return true;
     }

     public void insertAfter(JNode node) {
       checkRemoved();
       list = Lists.add(list, index + 1, (T) node);
       ++numVisitorChanges;
     }

     public void insertBefore(JNode node) {
       checkRemoved();
       list = Lists.add(list, index++, (T) node);
       ++numVisitorChanges;
     }

     public boolean isLvalue() {
       return false;
     }

     public void removeMe() {
       checkState();
       list = Lists.remove(list, index--);
       removed = true;
       ++numVisitorChanges;
     }

     public void replaceMe(JNode node) {
       checkState();
       checkReplacement(list.get(index), node);
       list = Lists.set(list, index, (T) node);
       replaced = true;
       ++numVisitorChanges;
     }

     /**
      * Cause my list to be traversed by this context.
      */
     protected List<T> traverse() {
       try {
         for (index = 0; index < list.size(); ++index) {
           removed = replaced = false;
           list.get(index).traverse(JModVisitor.this, this);
         }
         return list;
       } catch (Throwable e) {
         throw translateException(list.get(index), e);
       }
     }

     private void checkRemoved() {
       if (removed) {
         throw new InternalCompilerException("Node was already removed");
       }
     }

     private void checkState() {
       checkRemoved();
       if (replaced) {
         throw new InternalCompilerException("Node was already replaced");
       }
     }
   }

   private class LvalueContext extends NodeContext {
     public LvalueContext() {
       super(false);
     }

     @Override
     public boolean isLvalue() {
       return true;
     }
   }

   private class NodeContext implements Context {
     boolean canRemove;
     JNode node;
     boolean replaced;

     public NodeContext(boolean canRemove) {
       this.canRemove = canRemove;
     }

     public boolean canInsert() {
       return false;
     }

     public boolean canRemove() {
       return this.canRemove;
     }

     public void insertAfter(JNode node) {
       throw new UnsupportedOperationException("Can't insert after " + node);
     }

     public void insertBefore(JNode node) {
       throw new UnsupportedOperationException("Can't insert before " + node);
     }

     public boolean isLvalue() {
       return false;
     }

     public void removeMe() {
       if (!canRemove) {
         throw new UnsupportedOperationException("Can't remove " + node);
       }

       this.node = null;
       ++numVisitorChanges;
     }

     public void replaceMe(JNode node) {
       if (replaced) {
         throw new InternalCompilerException("Node was already replaced");
       }
       checkReplacement(this.node, node);
       this.node = node;
       replaced = true;
       ++numVisitorChanges;
     }
   }

   protected static void checkReplacement(JNode origNode, JNode newNode) {
     if (newNode == null) {
       throw new InternalCompilerException("Cannot replace with null");
     }
     if (newNode == origNode) {
       throw new InternalCompilerException("The replacement is the same as the original");
     }
   }

   private int numVisitorChanges = 0;

   @Override
   public JNode accept(JNode node) {
     return accept(node, false);
   }

   @Override
   public JNode accept(JNode node, boolean allowRemove) {
     NodeContext ctx = new NodeContext(allowRemove);
     try {
       ctx.node = node;
       traverse(node, ctx);
       return ctx.node;
     } catch (Throwable e) {
       throw translateException(node, e);
     }
   }

   @Override
   @SuppressWarnings("unchecked")
   public <T extends JNode> void accept(List<T> list) {
     NodeContext ctx = new NodeContext(false);
     try {
       for (int i = 0, c = list.size(); i < c; ++i) {
         ctx.node = list.get(i);
         traverse(ctx.node, ctx);
         if (ctx.replaced) {
           list.set(i, (T) ctx.node);
           ctx.replaced = false;
         }
       }
     } catch (Throwable e) {
       throw translateException(ctx.node, e);
     }
   }

   @SuppressWarnings("unchecked")
   @Override
   public <T extends JNode> List<T> acceptImmutable(List<T> list) {
     NodeContext ctx = new NodeContext(false);
     try {
       for (int i = 0, c = list.size(); i < c; ++i) {
         ctx.node = list.get(i);
         traverse(ctx.node, ctx);
         if (ctx.replaced) {
           list = Lists.set(list, i, (T) ctx.node);
           ctx.replaced = false;
         }
       }
       return list;
     } catch (Throwable e) {
       throw translateException(ctx.node, e);
     }
   }

   @Override
   public JExpression acceptLvalue(JExpression expr) {
     LvalueContext ctx = new LvalueContext();
     try {
       ctx.node = expr;
       traverse(expr, ctx);
       return (JExpression) ctx.node;
     } catch (Throwable e) {
       throw translateException(expr, e);
     }
   }

   @Override
   public <T extends JNode> void acceptWithInsertRemove(List<T> list) {
     new ListContext<T>(list).traverse();
   }

   @Override
   public <T extends JNode> List<T> acceptWithInsertRemoveImmutable(List<T> list) {
     return new ListContextImmutable<T>(list).traverse();
   }

   @Override
   public final boolean didChange() {
     return numVisitorChanges > 0;
   }

   /**
    * Returns the number of times the tree was changed since this visitor was
    * instantiated.
    */
   public int getNumMods() {
     return numVisitorChanges;
   }

   /**
    * Call this method to indicate that a visitor has made a change to the tree.
    * Used to determine when the optimization pass can exit.
    */
   protected void madeChanges() {
     ++numVisitorChanges;
   }

   protected void traverse(JNode node, Context context) {
     node.traverse(this, context);
   }
 }
	/*
	* Copyright 2008 Google Inc.
	*
	* 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.gwt.dev.jjs.ast;

	import com.google.gwt.dev.jjs.InternalCompilerException;
	import com.google.gwt.dev.util.collect.Lists;

	import java.util.List;

	/**
	* A visitor for iterating through and modifying an AST.
	*/
	public class JModVisitor extends JVisitor {

	/**
	* Context for traversing a mutable list.
	*/
	@SuppressWarnings("unchecked")
	private class ListContext<T extends JNode> implements Context {
	int index;
	final List<T> list;
	boolean removed;
	boolean replaced;

	public ListContext(List<T> list) {
	this.list = list;
	}

	public boolean canInsert() {
	return true;
	}

	public boolean canRemove() {
	return true;
	}

	public void insertAfter(JNode node) {
	checkRemoved();
	list.add(index + 1, (T) node);
	++numVisitorChanges;
	}

	public void insertBefore(JNode node) {
	checkRemoved();
	list.add(index++, (T) node);
	++numVisitorChanges;
	}

	public boolean isLvalue() {
	return false;
	}

	public void removeMe() {
	checkState();
	list.remove(index--);
	removed = true;
	++numVisitorChanges;
	}

	public void replaceMe(JNode node) {
	checkState();
	checkReplacement(list.get(index), node);
	list.set(index, (T) node);
	replaced = true;
	++numVisitorChanges;
	}

	/**
	* Cause my list to be traversed by this context.
	*/
	protected List<T> traverse() {
	try {
	for (index = 0; index < list.size(); ++index) {
	removed = replaced = false;
	list.get(index).traverse(JModVisitor.this, this);
	}
	return list;
	} catch (Throwable e) {
	throw translateException(list.get(index), e);
	}
	}

	private void checkRemoved() {
	if (removed) {
	throw new InternalCompilerException("Node was already removed");
	}
	}

	private void checkState() {
	checkRemoved();
	if (replaced) {
	throw new InternalCompilerException("Node was already replaced");
	}
	}
	}

	/**
	* Context for traversing an immutable list.
	*/
	@SuppressWarnings("unchecked")
	private class ListContextImmutable<T extends JNode> implements Context {
	int index;
	List<T> list;
	boolean removed;
	boolean replaced;

	public ListContextImmutable(List<T> list) {
	this.list = list;
	}

	public boolean canInsert() {
	return true;
	}

	public boolean canRemove() {
	return true;
	}

	public void insertAfter(JNode node) {
	checkRemoved();
	list = Lists.add(list, index + 1, (T) node);
	++numVisitorChanges;
	}

	public void insertBefore(JNode node) {
	checkRemoved();
	list = Lists.add(list, index++, (T) node);
	++numVisitorChanges;
	}

	public boolean isLvalue() {
	return false;
	}

	public void removeMe() {
	checkState();
	list = Lists.remove(list, index--);
	removed = true;
	++numVisitorChanges;
	}

	public void replaceMe(JNode node) {
	checkState();
	checkReplacement(list.get(index), node);
	list = Lists.set(list, index, (T) node);
	replaced = true;
	++numVisitorChanges;
	}

	/**
	* Cause my list to be traversed by this context.
	*/
	protected List<T> traverse() {
	try {
	for (index = 0; index < list.size(); ++index) {
	removed = replaced = false;
	list.get(index).traverse(JModVisitor.this, this);
	}
	return list;
	} catch (Throwable e) {
	throw translateException(list.get(index), e);
	}
	}

	private void checkRemoved() {
	if (removed) {
	throw new InternalCompilerException("Node was already removed");
	}
	}

	private void checkState() {
	checkRemoved();
	if (replaced) {
	throw new InternalCompilerException("Node was already replaced");
	}
	}
	}

	private class LvalueContext extends NodeContext {
	public LvalueContext() {
	super(false);
	}

	@Override
	public boolean isLvalue() {
	return true;
	}
	}

	private class NodeContext implements Context {
	boolean canRemove;
	JNode node;
	boolean replaced;

	public NodeContext(boolean canRemove) {
	this.canRemove = canRemove;
	}

	public boolean canInsert() {
	return false;
	}

	public boolean canRemove() {
	return this.canRemove;
	}

	public void insertAfter(JNode node) {
	throw new UnsupportedOperationException("Can't insert after " + node);
	}

	public void insertBefore(JNode node) {
	throw new UnsupportedOperationException("Can't insert before " + node);
	}

	public boolean isLvalue() {
	return false;
	}

	public void removeMe() {
	if (!canRemove) {
	throw new UnsupportedOperationException("Can't remove " + node);
	}

	this.node = null;
	++numVisitorChanges;
	}

	public void replaceMe(JNode node) {
	if (replaced) {
	throw new InternalCompilerException("Node was already replaced");
	}
	checkReplacement(this.node, node);
	this.node = node;
	replaced = true;
	++numVisitorChanges;
	}
	}

	protected static void checkReplacement(JNode origNode, JNode newNode) {
	if (newNode == null) {
	throw new InternalCompilerException("Cannot replace with null");
	}
	if (newNode == origNode) {
	throw new InternalCompilerException("The replacement is the same as the original");
	}
	}

	private int numVisitorChanges = 0;

	@Override
	public JNode accept(JNode node) {
	return accept(node, false);
	}

	@Override
	public JNode accept(JNode node, boolean allowRemove) {
	NodeContext ctx = new NodeContext(allowRemove);
	try {
	ctx.node = node;
	traverse(node, ctx);
	return ctx.node;
	} catch (Throwable e) {
	throw translateException(node, e);
	}
	}

	@Override
	@SuppressWarnings("unchecked")
	public <T extends JNode> void accept(List<T> list) {
	NodeContext ctx = new NodeContext(false);
	try {
	for (int i = 0, c = list.size(); i < c; ++i) {
	ctx.node = list.get(i);
	traverse(ctx.node, ctx);
	if (ctx.replaced) {
	list.set(i, (T) ctx.node);
	ctx.replaced = false;
	}
	}
	} catch (Throwable e) {
	throw translateException(ctx.node, e);
	}
	}

	@SuppressWarnings("unchecked")
	@Override
	public <T extends JNode> List<T> acceptImmutable(List<T> list) {
	NodeContext ctx = new NodeContext(false);
	try {
	for (int i = 0, c = list.size(); i < c; ++i) {
	ctx.node = list.get(i);
	traverse(ctx.node, ctx);
	if (ctx.replaced) {
	list = Lists.set(list, i, (T) ctx.node);
	ctx.replaced = false;
	}
	}
	return list;
	} catch (Throwable e) {
	throw translateException(ctx.node, e);
	}
	}

	@Override
	public JExpression acceptLvalue(JExpression expr) {
	LvalueContext ctx = new LvalueContext();
	try {
	ctx.node = expr;
	traverse(expr, ctx);
	return (JExpression) ctx.node;
	} catch (Throwable e) {
	throw translateException(expr, e);
	}
	}

	@Override
	public <T extends JNode> void acceptWithInsertRemove(List<T> list) {
	new ListContext<T>(list).traverse();
	}

	@Override
	public <T extends JNode> List<T> acceptWithInsertRemoveImmutable(List<T> list) {
	return new ListContextImmutable<T>(list).traverse();
	}

	@Override
	public final boolean didChange() {
	return numVisitorChanges > 0;
	}

	/**
	* Returns the number of times the tree was changed since this visitor was
	* instantiated.
	*/
	public int getNumMods() {
	return numVisitorChanges;
	}

	/**
	* Call this method to indicate that a visitor has made a change to the tree.
	* Used to determine when the optimization pass can exit.
	*/
	protected void madeChanges() {
	++numVisitorChanges;
	}

	protected void traverse(JNode node, Context context) {
	node.traverse(this, context);
	}
	}