Project: RadRails1.0

Revision: 14211

Author: cwilliams

Date: 23 Jun 2008 10:12:29

• /aptana/ide_suite/branches/radrails_1.0/rdt/plugins/com.aptana.rdt.tests/src/com/aptana/rdt/internal/core/parser/warnings/TC_SimilarVariableNameVisitor.java

  ......	@@ -160,5 +160,19 @@
  160	160	parse(code);
  161	161	assertEquals(1, numberOfProblems());
  162	162	}
  	163
  	164	public void testHandleVarsOutsideMethods() throws Exception {
  	165	String code = "class Ralph\n" +
  	166	" @@class_var = 1\n" +
  	167	" def initialize(name)\n" +
  	168	" @name = name\n" +
  	169	" end\n" +
  	170	" def name\n" +
  	171	" @@class_val\n" +
  	172	" end\n" +
  	173	"end\n";
  	174	parse(code);
  	175	assertEquals(1, numberOfProblems());
  	176	}
  163	177
  164	178	}

• /aptana/ide_suite/branches/radrails_1.0/rdt/plugins/com.aptana.rdt/src/com/aptana/rdt/internal/parser/warnings/SimilarVariableNameVisitor.java

  ......	@@ -18,7 +18,10 @@
  18	18	import org.jruby.ast.ListNode;
  19	19	import org.jruby.ast.LocalAsgnNode;
  20	20	import org.jruby.ast.LocalVarNode;
  	21	import org.jruby.ast.MethodDefNode;
  21	22	import org.jruby.ast.Node;
  	23	import org.jruby.ast.RootNode;
  	24	import org.jruby.ast.SClassNode;
  22	25	import org.jruby.ast.VCallNode;
  23	26	import org.jruby.ast.types.INameNode;
  24	27	import org.jruby.evaluator.Instruction;
  ......	@@ -28,36 +31,38 @@
  28	31
  29	32	public class SimilarVariableNameVisitor extends RubyLintVisitor {
  30	33
  31		private List<Map<String, Node>> stack;
  32
  	34	private Map<Node, Map<String, Node>> scopesToVars;
  	35	private List<Node> scopes;
  	36
  33	37	public SimilarVariableNameVisitor(String contents) {
  34	38	super(AptanaRDTPlugin.getDefault().getOptions(), contents);
  35		stack = new ArrayList<Map<String, Node>>();
  	39	scopes = new ArrayList<Node>();
  	40	scopesToVars = new HashMap<Node, Map<String,Node>>();
  36	41	}
  37	42
  38		@Override
  39	43	protected String getOptionKey() {
  40	44	return AptanaRDTPlugin.COMPILER_PB_SIMILAR_VARIABLE_NAMES;
  41	45	}
  42	46
  43		@Override
  44	47	public Instruction visitDefnNode(DefnNode iVisited) {
  45		enterMethod();
  	48	enterMethod(iVisited);
  46	49	return super.visitDefnNode(iVisited);
  47	50	}
  48	51
  49		@Override
  50	52	public Instruction visitDefsNode(DefsNode iVisited) {
  51		enterMethod();
  	53	enterMethod(iVisited);
  52	54	return super.visitDefsNode(iVisited);
  53	55	}
  54	56
  55		private void enterMethod() {
  56		// TODO Auto-generated method stub
  57		enterScope();
  	57	private void enterMethod(MethodDefNode node) {
  	58	enterScope(node);
  	59	}
  	60
  	61	public Instruction visitClassNode(ClassNode visited) {
  	62	enterScope(visited);
  	63	return super.visitClassNode(visited);
  58	64	}
  59	65
  60		@Override
  61	66	public Instruction visitArgsNode(ArgsNode iVisited) {
  62	67	ListNode list = iVisited.getArgs();
  63	68	if (list != null && list.childNodes() != null) {
  ......	@@ -76,36 +81,49 @@
  76	81	return super.visitArgsNode(iVisited);
  77	82	}
  78	83
  79		@Override
  80	84	public void exitDefnNode(DefnNode iVisited) {
  81	85	exitMethod();
  82	86	super.exitDefnNode(iVisited);
  83	87	}
  84	88
  85		@Override
  86	89	public Instruction visitBlockNode(BlockNode iVisited) {
  87		enterScope();
  	90	enterScope(iVisited);
  88	91	return super.visitBlockNode(iVisited);
  89	92	}
  90	93
  91		private void enterScope() {
  92		stack.add(new HashMap<String, Node>());
  	94	private void enterScope(Node node) {
  	95	scopes.add(node);
  	96	scopesToVars.put(node, new HashMap<String, Node>());
  93	97	}
  94	98
  95		@Override
  96	99	public void exitBlockNode(BlockNode iVisited) {
  97	100	exitScope();
  98	101	super.exitBlockNode(iVisited);
  99	102	}
  100	103
  	104	private void exitClass()
  	105	{
  	106	exitScope(true);
  	107	}
  	108
  101	109	private void exitScope() {
  	110	exitScope(false);
  	111	}
  	112
  	113	private void exitScope(boolean exitingClass) {
  	114	Map<String, Node> vars = getAllVarsInScope();
  	115	pop();
  	116
  102	117	// FIXME Only create warnings on references to variables that have no declaration
  103		Map<String, Node> map = stack.remove(stack.size() - 1); // pop
  104		List<String> names = new ArrayList<String>(map.keySet());
  	118	List<String> names = new ArrayList<String>(vars.keySet());
  105	119	while (!names.isEmpty()) {
  106	120	String name = names.remove(0);
  107	121	boolean isInstanceVar = isInstanceVar(name);
  108	122	boolean isClassVar = isClassVar(name);
  	123	if (!exitingClass && (isClassVar || isInstanceVar))
  	124	{
  	125	continue;
  	126	}
  109	127	for (String string : names) {
  110	128	// Strip off @s?
  111	129	String modName = name;
  ......	@@ -129,13 +147,26 @@
  129	147	continue;
  130	148	}
  131	149	if (damerauLevenshteinDistance(modName, string) <= levenshteinThreshold(modName)) {
  132		createProblem(map.get(name).getPosition(),
  	150	createProblem(vars.get(name).getPosition(),
  133	151	"Variable has similar name to another in scope: Possible misspelling."); // FIXME Shouldn't create a problem if there is a method with this name!
  134	152	}
  135	153	}
  136	154	}
  137	155	}
  138	156
  	157	private Map<String, Node> getAllVarsInScope() {
  	158	Map<String, Node> all = new HashMap<String, Node>();
  	159	for (Node scopeNode : scopes) {
  	160	all.putAll(scopesToVars.get(scopeNode));
  	161	}
  	162	return all;
  	163	}
  	164
  	165	private void pop() {
  	166	Node scopeNode = scopes.remove(scopes.size() - 1);
  	167	scopesToVars.remove(scopeNode);
  	168	}
  	169
  139	170	private boolean isPlural(String singular, String plural) {
  140	171	return (singular.length() == plural.length() - 1) && (singular.equals(plural.substring(0, plural.length() - 1))) &&
  141	172	plural.charAt(plural.length() - 1) == 's';
  ......	@@ -219,42 +250,60 @@
  219	250	return y;
  220	251	}
  221	252
  222		@Override
  223	253	public Instruction visitVCallNode(VCallNode iVisited) {
  224	254	addVar(iVisited);
  225	255	return super.visitVCallNode(iVisited);
  226	256	}
  227	257
  228		@Override
  229	258	public Instruction visitLocalAsgnNode(LocalAsgnNode iVisited) {
  230	259	addVar(iVisited);
  231	260	return super.visitLocalAsgnNode(iVisited);
  232	261	}
  233	262
  234		@Override
  235	263	public Instruction visitLocalVarNode(LocalVarNode iVisited) {
  236	264	addVar(iVisited);
  237	265	return super.visitLocalVarNode(iVisited);
  238	266	}
  239	267
  	268	private void addToClass(INameNode iVisited) {
  	269	int i = 1;
  	270	Node scopeNode = null;
  	271	while( true )
  	272	{
  	273	scopeNode = scopes.get(scopes.size() - i);
  	274	if (scopeNode instanceof ClassNode || scopeNode instanceof SClassNode || scopeNode instanceof RootNode)
  	275	{
  	276	addToScope(iVisited, scopeNode);
  	277	break;
  	278	}
  	279	i++;
  	280	if (i > scopes.size()) break;
  	281	}
  	282	}
  	283
  240	284	private void addVar(INameNode iVisited) {
  241		Map<String, Node> map;
  242		if (stack.isEmpty()) {
  243		map = new HashMap<String, Node>();
  244		stack.add(map);
  245		} else {
  246		map = stack.get(stack.size() - 1);
  	285	Node scopeNode = scopes.get(scopes.size() - 1);
  	286	addToScope(iVisited, scopeNode);
  	287	}
  	288
  	289	private void addToScope(INameNode iVisited, Node scopeNode) {
  	290	Map<String, Node> vars = scopesToVars.get(scopeNode);
  	291	if (vars == null)
  	292	{
  	293	vars = new HashMap<String, Node>();
  247	294	}
  248		map.put(iVisited.getName(), (Node) iVisited);
  	295	vars.put(iVisited.getName(), (Node) iVisited);
  	296	}
  	297
  	298	public Instruction visitRootNode(RootNode visited) {
  	299	enterScope(visited);
  	300	return super.visitRootNode(visited);
  249	301	}
  250	302
  251		@Override
  252	303	public void exitClassNode(ClassNode iVisited) {
  253		// TODO Check for references to class and instance variables that have no declaration/assignment
  254		super.exitClassNode(iVisited);
  	304	exitClass();
  255	305	}
  256	306
  257		@Override
  258	307	public void exitDefsNode(DefsNode iVisited) {
  259	308	exitMethod();
  260	309	super.exitDefsNode(iVisited);
  ......	@@ -265,33 +314,28 @@
  265	314	exitScope();
  266	315	}
  267	316
  268		@Override
  269	317	public Instruction visitInstAsgnNode(InstAsgnNode iVisited) {
  270		addVar(iVisited);
  	318	addToClass(iVisited);
  271	319	return super.visitInstAsgnNode(iVisited);
  272	320	}
  273	321
  274		@Override
  275	322	public Instruction visitInstVarNode(InstVarNode iVisited) {
  276		addVar(iVisited);
  	323	addToClass(iVisited);
  277	324	return super.visitInstVarNode(iVisited);
  278	325	}
  279	326
  280		@Override
  281	327	public Instruction visitClassVarAsgnNode(ClassVarAsgnNode iVisited) {
  282		addVar(iVisited);
  	328	addToClass(iVisited);
  283	329	return super.visitClassVarAsgnNode(iVisited);
  284	330	}
  285	331
  286		@Override
  287	332	public Instruction visitClassVarNode(ClassVarNode iVisited) {
  288		addVar(iVisited);
  	333	addToClass(iVisited);
  289	334	return super.visitClassVarNode(iVisited);
  290	335	}
  291	336
  292		@Override
  293	337	public Instruction visitClassVarDeclNode(ClassVarDeclNode iVisited) {
  294		addVar(iVisited);
  	338	addToClass(iVisited);
  295	339	return super.visitClassVarDeclNode(iVisited);
  296	340	}
  297	341