AutoImporter.java

/*
 * AutoImportor.java
 * 
 * Copyright (c) 2006-2007 David Holroyd
 *
 * 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 uk.co.badgersinfoil.metaas.impl;

import java.util.ArrayList;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Set;
import org.asdt.core.internal.antlr.AS3Parser;
import uk.co.badgersinfoil.metaas.dom.ASArg;
import uk.co.badgersinfoil.metaas.dom.ASClassType;
import uk.co.badgersinfoil.metaas.dom.ASInterfaceType;
import uk.co.badgersinfoil.metaas.dom.ASMember;
import uk.co.badgersinfoil.metaas.dom.ASMethod;
import uk.co.badgersinfoil.metaas.dom.ASPackage;
import uk.co.badgersinfoil.metaas.dom.ASType;
import uk.co.badgersinfoil.metaas.impl.antlr.LinkedListTree;


/**
 * Modify all CompilationUnits in an ASProject so that fully qualified names
 * in the code are replaced with unqualified names, and the appropriate
 * import statements are added to the package declaration. 
 */
public class AutoImporter {

	private List visibleQNames = new ArrayList();
	
	// TODO: maintaining a list of names that *could* clash is not as nice
	// as actually working out which names *do* clash in a particular
	// compilation unit.  However, that would require two passes over the
	// compilation unit, so we're taking the simpler route for the mo.
	private Set possiblyAmbigLocalNames = new HashSet();

	public void performAutoImport(ASTActionScriptProject project) {
		loadAccessableLanguageElements(project);
		processSources(project);
	}

	private void loadAccessableLanguageElements(ASTActionScriptProject project) {
		final Set seenLocalNames = new HashSet();
		
		// look for definitions within the current project code itself
		ASVisitor visitor = new ASVisitor.Null() {
			public void visit(ASPackage pkg) {
				// TODO: will need to look for other top-level
				// elements, once metaas has support for them
				ASType type = pkg.getType();
				ASQName name = new ASQName(pkg.getName(), type.getName());
				visibleQNames.add(name);
				if (seenLocalNames.contains(name.getLocalName())) {
					possiblyAmbigLocalNames.add(name.getLocalName());
				} else {
					seenLocalNames.add(name.getLocalName());
				}
			}
		};
		new ASWalker(visitor).walk(project);

		// handle project classpath definitions
		Iterator i = project.getResourceRoots().iterator();
		while (i.hasNext()) {
			ResourceRoot resourceRoot = (ResourceRoot)i.next();
			Iterator j = resourceRoot.getDefinitionQNames().iterator();
			while (j.hasNext()) {
				ASQName name = (ASQName)j.next();
				visibleQNames.add(name);
				if (seenLocalNames.contains(name.getLocalName())) {
					possiblyAmbigLocalNames.add(name.getLocalName());
				} else {
					seenLocalNames.add(name.getLocalName());
				}
			}
		}
	}


	private void processSources(ASTActionScriptProject project) {
		new ASWalker(new ImportSourceProcessor()).walk(project);
	}

	private class ImportSourceProcessor extends ASVisitor.Null {
		private String currentPackageName;
		private ASQName currentTypeName;
		private ASPackage currentPackage;
		private Set currentPackageImports = new HashSet();
		private ASType currentType;

		// TODO: handle local names that would be ambiguous if not
		// fully-qualified.

		public void visit(ASPackage pkg) {
			currentPackage = pkg;
			currentPackageName = pkg.getName();
			inspectImports(pkg);
		}

		private void inspectImports(ASPackage pkg) {
			currentPackageImports.clear();
			List imports = pkg.findImports();
			for (Iterator i=imports.iterator(); i.hasNext(); ) {
				ASQName imp = new ASQName((String)i.next());
				if (imp.getLocalName().equals("*")) {
					// expand, to list all the imported names
					importNamesFromPackage(imp.getPackagePrefix());
				} else {
					currentPackageImports.add(imp);
				}
			}
		}

		private void importNamesFromPackage(String packagePrefix) {
			for (Iterator i=visibleQNames.iterator(); i.hasNext(); ) {
				ASQName name = (ASQName)i.next();
				if (packagePrefix.equals(name.getPackagePrefix())) {
					currentPackageImports.add(name);
				}
			}
		}

		public void visit(ASType type) {
			currentTypeName = new ASQName(currentPackageName, type.getName());
			currentType = type;
		}
		
		public void visit(ASClassType clazz) {
			String superClassName = clazz.getSuperclass();
			String processed = processTypeName(superClassName);
			if (processed != null) {
				clazz.setSuperclass(processed);
			}
			List interfaceNames = clazz.getImplementedInterfaces();
			for (Iterator i=interfaceNames.iterator(); i.hasNext(); ) {
				String interfaceName = (String)i.next();
				processed = processTypeName(interfaceName);
				if (processed != null) {
					clazz.removeImplementedInterface(interfaceName);
					clazz.addImplementedInterface(processed);
				}
			}
		}

		public void visit(ASInterfaceType iface) {
			List interfaceNames = iface.getSuperInterfaces();
			for (Iterator i=interfaceNames.iterator(); i.hasNext(); ) {
				String interfaceName = (String)i.next();
				String processed = processTypeName(interfaceName);
				if (processed != null) {
					iface.removeSuperInterface(interfaceName);
					iface.addSuperInterface(processed);
				}
			}
		}

		public void visit(ASMember member) {
			String processedName = processTypeName(member.getType());
			if (processedName != null) {
				member.setType(processedName);
			}
		}

		private String processTypeName(String typeName) {
			if (typeName != null) {
				ASQName qname = new ASQName(typeName);
				if (qname.isQualified()
				    && visibleQNames.contains(qname))
				{
					if (importRequired(qname)) {
						addImport(qname);
					}
					if (!possiblyAmbigLocalNames.contains(qname.getLocalName())) {
						return qname.getLocalName();
					}
				}
			}
			return null;
		}

		private boolean importRequired(ASQName qname) {
			if (currentPackageName != null && currentPackageName.equals(qname.getPackagePrefix())) {
				return false;
			}
			return !currentPackageImports.contains(qname);
		}

		private void addImport(ASQName qname) {
			currentPackage.addImport(qname.toString());
			currentPackageImports.add(qname);
		}

		public void visit(ASMethod method) {
			// there's no visit(ASArg),
			processAllArgs(method);
			if (currentType instanceof ASClassType) {
				// the methods in an interface lack a body,
				processBody(method);
			}
		}

		private void processAllArgs(ASMethod method) {
			List args = method.getArgs();
			for (Iterator i=args.iterator(); i.hasNext(); ) {
				processArg((ASArg)i.next());
			}
		}

		private void processArg(ASArg arg) {
			String processedName = processTypeName(arg.getType());
			if (processedName != null) {
				arg.setType(processedName);
			}
		}

		private void processBody(ASMethod method) {
			LinkedListTree ast = ((ASTASMethod)method).getAST();
			LinkedListTree body = (LinkedListTree)ast.getFirstChildWithType(AS3Parser.BLOCK);
			processTreeForImports(body);
		}

		// metaas doesn't have any representations for things at the
		// statement / expression level, so now we have to walk the AST,

		private void processTreeForImports(LinkedListTree ast) {
			if (processNodeForImports(ast)) {
				for (int i=0; i<ast.getChildCount(); i++) {
					LinkedListTree child = (LinkedListTree)ast.getChild(i);
					processTreeForImports(child);
				}
			}
		}

		private boolean processNodeForImports(LinkedListTree ast) {
			switch (ast.getType()) {
			case AS3Parser.TYPE_SPEC:
				processTypeSpecForImports(ast);
				return false;
			case AS3Parser.IDENTIFIER:
				processIdentifierForImports(ast);
				return false;
			case AS3Parser.PROPERTY_OR_IDENTIFIER:
				processPropertyOrIdentifierForImports(ast);
				return false;
			}
			return true;
		}

		private void processTypeSpecForImports(LinkedListTree ast) {
			String typeName = ASTUtils.typeSpecText(ast);
			String processedName = processTypeName(typeName);
			if (processedName != null) {
				LinkedListTree newTypeSpec = AS3FragmentParser.parseTypeSpec(processedName);
				ast.setChildWithTokens(0, newTypeSpec.getFirstChild());
			}
		}

		private void processIdentifierForImports(LinkedListTree ast) {
System.out.println(ASTUtils.identText(ast));
		}

		private ASQName processPropertyOrIdentifierForImports(LinkedListTree ast) {
//System.out.println("processPropertyOrIdentifierForImports("+ast.toStringTree()+")");
			LinkedListTree target = ast.getFirstChild();
			LinkedListTree name = ast.getLastChild();
			if (name.getType() != AS3Parser.IDENT) {
				return null;
			}
			ASQName qname = null;
			if (target.getType() == AS3Parser.PROPERTY_OR_IDENTIFIER) {
				ASQName tmp = processPropertyOrIdentifierForImports(target);
				if (tmp != null) {
					qname = new ASQName(tmp.toString(), name.getText());
				}
			} else if (target.getType() == AS3Parser.IDENT) {
				qname = new ASQName(target.getText(), name.getText());
			}
			if (qname == null) {
				ast.token.setType(AS3Parser.PROPERTY_ACCESS);
			} else {
				String processedName = processTypeName(qname.toString());
//System.out.println("  : processTypeName("+qname+") => "+processedName);
				if (processedName != null) {
//System.out.println("  : ast.start="+ast.getStartToken()+" ast.stop="+ast.getStopToken());
					int myIndex = ast.getParent().getIndexOfChild(ast);
					ast.getParent().setChildWithTokens(myIndex, ASTUtils.newAST(AS3Parser.IDENT, processedName));
					qname = null;
				}
			}
			return qname;
		}
	}
}