Menu
▾
▴
[Rubyeclipse-commit] SF.net SVN: rubyeclipse: [2952] trunk/org.rubypeople.rdt.core
|
From: <caw...@us...> - 2007-08-09 14:21:56
|
Revision: 2952
http://rubyeclipse.svn.sourceforge.net/rubyeclipse/?rev=2952&view=rev
Author: cawilliams
Date: 2007-08-09 07:21:16 -0700 (Thu, 09 Aug 2007)
Log Message:
-----------
move useful warning classes to externally visible package
Modified Paths:
--------------
trunk/org.rubypeople.rdt.core/META-INF/MANIFEST.MF
trunk/org.rubypeople.rdt.core/src/org/rubypeople/rdt/internal/core/RubyScriptProblemFinder.java
trunk/org.rubypeople.rdt.core/src/org/rubypeople/rdt/internal/core/builder/RubyCodeAnalyzer.java
trunk/org.rubypeople.rdt.core/src/org/rubypeople/rdt/internal/core/parser/warnings/ConstantReassignmentVisitor.java
trunk/org.rubypeople.rdt.core/src/org/rubypeople/rdt/internal/core/parser/warnings/EmptyStatementVisitor.java
Added Paths:
-----------
trunk/org.rubypeople.rdt.core/src/org/rubypeople/rdt/core/parser/warnings/DelegatingVisitor.java
trunk/org.rubypeople.rdt.core/src/org/rubypeople/rdt/core/parser/warnings/RubyLintVisitor.java
Removed Paths:
-------------
trunk/org.rubypeople.rdt.core/src/org/rubypeople/rdt/internal/core/parser/warnings/DelegatingVisitor.java
trunk/org.rubypeople.rdt.core/src/org/rubypeople/rdt/internal/core/parser/warnings/RubyLintVisitor.java
Modified: trunk/org.rubypeople.rdt.core/META-INF/MANIFEST.MF
===================================================================
--- trunk/org.rubypeople.rdt.core/META-INF/MANIFEST.MF 2007-08-09 14:18:53 UTC (rev 2951)
+++ trunk/org.rubypeople.rdt.core/META-INF/MANIFEST.MF 2007-08-09 14:21:16 UTC (rev 2952)
@@ -11,6 +11,7 @@
org.rubypeople.rdt.core,
org.rubypeople.rdt.core.compiler,
org.rubypeople.rdt.core.formatter,
+ org.rubypeople.rdt.core.parser.warnings,
org.rubypeople.rdt.core.search,
org.rubypeople.rdt.core.util,
org.rubypeople.rdt.internal.compiler,
Copied: trunk/org.rubypeople.rdt.core/src/org/rubypeople/rdt/core/parser/warnings/DelegatingVisitor.java (from rev 2724, trunk/org.rubypeople.rdt.core/src/org/rubypeople/rdt/internal/core/parser/warnings/DelegatingVisitor.java)
===================================================================
--- trunk/org.rubypeople.rdt.core/src/org/rubypeople/rdt/core/parser/warnings/DelegatingVisitor.java (rev 0)
+++ trunk/org.rubypeople.rdt.core/src/org/rubypeople/rdt/core/parser/warnings/DelegatingVisitor.java 2007-08-09 14:21:16 UTC (rev 2952)
@@ -0,0 +1,928 @@
+package org.rubypeople.rdt.core.parser.warnings;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.jruby.ast.AliasNode;
+import org.jruby.ast.AndNode;
+import org.jruby.ast.ArgsCatNode;
+import org.jruby.ast.ArgsNode;
+import org.jruby.ast.ArgsPushNode;
+import org.jruby.ast.ArrayNode;
+import org.jruby.ast.AttrAssignNode;
+import org.jruby.ast.BackRefNode;
+import org.jruby.ast.BeginNode;
+import org.jruby.ast.BignumNode;
+import org.jruby.ast.BlockArgNode;
+import org.jruby.ast.BlockNode;
+import org.jruby.ast.BlockPassNode;
+import org.jruby.ast.BreakNode;
+import org.jruby.ast.CallNode;
+import org.jruby.ast.CaseNode;
+import org.jruby.ast.ClassNode;
+import org.jruby.ast.ClassVarAsgnNode;
+import org.jruby.ast.ClassVarDeclNode;
+import org.jruby.ast.ClassVarNode;
+import org.jruby.ast.Colon2Node;
+import org.jruby.ast.Colon3Node;
+import org.jruby.ast.ConstDeclNode;
+import org.jruby.ast.ConstNode;
+import org.jruby.ast.DAsgnNode;
+import org.jruby.ast.DRegexpNode;
+import org.jruby.ast.DStrNode;
+import org.jruby.ast.DSymbolNode;
+import org.jruby.ast.DVarNode;
+import org.jruby.ast.DXStrNode;
+import org.jruby.ast.DefinedNode;
+import org.jruby.ast.DefnNode;
+import org.jruby.ast.DefsNode;
+import org.jruby.ast.DotNode;
+import org.jruby.ast.EnsureNode;
+import org.jruby.ast.EvStrNode;
+import org.jruby.ast.FCallNode;
+import org.jruby.ast.FalseNode;
+import org.jruby.ast.FixnumNode;
+import org.jruby.ast.FlipNode;
+import org.jruby.ast.FloatNode;
+import org.jruby.ast.ForNode;
+import org.jruby.ast.GlobalAsgnNode;
+import org.jruby.ast.GlobalVarNode;
+import org.jruby.ast.HashNode;
+import org.jruby.ast.IfNode;
+import org.jruby.ast.InstAsgnNode;
+import org.jruby.ast.InstVarNode;
+import org.jruby.ast.IterNode;
+import org.jruby.ast.LocalAsgnNode;
+import org.jruby.ast.LocalVarNode;
+import org.jruby.ast.Match2Node;
+import org.jruby.ast.Match3Node;
+import org.jruby.ast.MatchNode;
+import org.jruby.ast.ModuleNode;
+import org.jruby.ast.MultipleAsgnNode;
+import org.jruby.ast.NewlineNode;
+import org.jruby.ast.NextNode;
+import org.jruby.ast.NilNode;
+import org.jruby.ast.NotNode;
+import org.jruby.ast.NthRefNode;
+import org.jruby.ast.OpAsgnAndNode;
+import org.jruby.ast.OpAsgnNode;
+import org.jruby.ast.OpAsgnOrNode;
+import org.jruby.ast.OpElementAsgnNode;
+import org.jruby.ast.OptNNode;
+import org.jruby.ast.OrNode;
+import org.jruby.ast.PostExeNode;
+import org.jruby.ast.RedoNode;
+import org.jruby.ast.RegexpNode;
+import org.jruby.ast.RescueBodyNode;
+import org.jruby.ast.RescueNode;
+import org.jruby.ast.RetryNode;
+import org.jruby.ast.ReturnNode;
+import org.jruby.ast.RootNode;
+import org.jruby.ast.SClassNode;
+import org.jruby.ast.SValueNode;
+import org.jruby.ast.SelfNode;
+import org.jruby.ast.SplatNode;
+import org.jruby.ast.StrNode;
+import org.jruby.ast.SuperNode;
+import org.jruby.ast.SymbolNode;
+import org.jruby.ast.ToAryNode;
+import org.jruby.ast.TrueNode;
+import org.jruby.ast.UndefNode;
+import org.jruby.ast.UntilNode;
+import org.jruby.ast.VAliasNode;
+import org.jruby.ast.VCallNode;
+import org.jruby.ast.WhenNode;
+import org.jruby.ast.WhileNode;
+import org.jruby.ast.XStrNode;
+import org.jruby.ast.YieldNode;
+import org.jruby.ast.ZArrayNode;
+import org.jruby.ast.ZSuperNode;
+import org.jruby.evaluator.Instruction;
+import org.rubypeople.rdt.core.compiler.CategorizedProblem;
+import org.rubypeople.rdt.internal.core.parser.InOrderVisitor;
+import org.rubypeople.rdt.internal.core.parser.warnings.ConstantReassignmentVisitor;
+import org.rubypeople.rdt.internal.core.parser.warnings.EmptyStatementVisitor;
+
+/**
+ * <p>DelegatingVisitor takes a list of visitors, traverse the AST in order, and at
+ * each node calls the correct visitXXXNode method on every visitor. This allows
+ * us to traverse the AST only once while having X number of visitors operate on
+ * it.</p>
+ *
+ * <p>Right now it is customized to RubyLintVisitors, which is the abstract
+ * base class for all visitors that do coce analysis for Error/Warning markers.</p>
+ *
+ * @author Christopher Williams
+ *
+ */
+public class DelegatingVisitor extends InOrderVisitor {
+
+ private List<RubyLintVisitor> visitors;
+
+ public static List<RubyLintVisitor> createVisitors(String contents) {
+ List<RubyLintVisitor> visitors = new ArrayList<RubyLintVisitor>();
+ // FIXME Run through a map of keys to classes and add instances of
+ // classes whose key is not set to ignore
+ visitors.add(new EmptyStatementVisitor(contents));
+ visitors.add(new ConstantReassignmentVisitor(contents));
+ return visitors;
+ }
+
+ public List<CategorizedProblem> getProblems() {
+ List<CategorizedProblem> problems = new ArrayList<CategorizedProblem>();
+ for (RubyLintVisitor visitor : visitors) {
+ problems.addAll(visitor.getProblems());
+ }
+ return problems;
+ }
+
+ public DelegatingVisitor(List<RubyLintVisitor> visitors) {
+ this.visitors = visitors;
+ }
+
+ @Override
+ public Instruction visitAliasNode(AliasNode iVisited) {
+ for (RubyLintVisitor visitor : visitors) {
+ visitor.visitAliasNode(iVisited);
+ }
+ return super.visitAliasNode(iVisited);
+ }
+
+ @Override
+ public Instruction visitAndNode(AndNode iVisited) {
+ for (RubyLintVisitor visitor : visitors) {
+ visitor.visitAndNode(iVisited);
+ }
+ return super.visitAndNode(iVisited);
+ }
+
+ @Override
+ public Instruction visitArgsCatNode(ArgsCatNode iVisited) {
+ for (RubyLintVisitor visitor : visitors) {
+ visitor.visitArgsCatNode(iVisited);
+ }
+ return super.visitArgsCatNode(iVisited);
+ }
+
+ @Override
+ public Instruction visitArgsNode(ArgsNode iVisited) {
+ for (RubyLintVisitor visitor : visitors) {
+ visitor.visitArgsNode(iVisited);
+ }
+ return super.visitArgsNode(iVisited);
+ }
+
+ @Override
+ public Instruction visitArgsPushNode(ArgsPushNode iVisited) {
+ for (RubyLintVisitor visitor : visitors) {
+ visitor.visitArgsPushNode(iVisited);
+ }
+ return super.visitArgsPushNode(iVisited);
+ }
+
+ @Override
+ public Instruction visitArrayNode(ArrayNode iVisited) {
+ for (RubyLintVisitor visitor : visitors) {
+ visitor.visitArrayNode(iVisited);
+ }
+ return super.visitArrayNode(iVisited);
+ }
+
+ @Override
+ public Instruction visitAttrAssignNode(AttrAssignNode iVisited) {
+ for (RubyLintVisitor visitor : visitors) {
+ visitor.visitAttrAssignNode(iVisited);
+ }
+ return super.visitAttrAssignNode(iVisited);
+ }
+
+ @Override
+ public Instruction visitBackRefNode(BackRefNode iVisited) {
+ for (RubyLintVisitor visitor : visitors) {
+ visitor.visitBackRefNode(iVisited);
+ }
+ return super.visitBackRefNode(iVisited);
+ }
+
+ @Override
+ public Instruction visitBeginNode(BeginNode iVisited) {
+ for (RubyLintVisitor visitor : visitors) {
+ visitor.visitBeginNode(iVisited);
+ }
+ return super.visitBeginNode(iVisited);
+ }
+
+ @Override
+ public Instruction visitBignumNode(BignumNode iVisited) {
+ for (RubyLintVisitor visitor : visitors) {
+ visitor.visitBignumNode(iVisited);
+ }
+ return super.visitBignumNode(iVisited);
+ }
+
+ @Override
+ public Instruction visitBlockArgNode(BlockArgNode iVisited) {
+ for (RubyLintVisitor visitor : visitors) {
+ visitor.visitBlockArgNode(iVisited);
+ }
+ return super.visitBlockArgNode(iVisited);
+ }
+
+ @Override
+ public Instruction visitBlockNode(BlockNode iVisited) {
+ for (RubyLintVisitor visitor : visitors) {
+ visitor.visitBlockNode(iVisited);
+ }
+ Instruction ins = super.visitBlockNode(iVisited);
+ for (RubyLintVisitor visitor : visitors) {
+ visitor.exitBlockNode(iVisited);
+ }
+ return ins;
+ }
+
+ @Override
+ public Instruction visitBlockPassNode(BlockPassNode iVisited) {
+ for (RubyLintVisitor visitor : visitors) {
+ visitor.visitBlockPassNode(iVisited);
+ }
+ return super.visitBlockPassNode(iVisited);
+ }
+
+ @Override
+ public Instruction visitBreakNode(BreakNode iVisited) {
+ for (RubyLintVisitor visitor : visitors) {
+ visitor.visitBreakNode(iVisited);
+ }
+ return super.visitBreakNode(iVisited);
+ }
+
+ @Override
+ public Instruction visitCallNode(CallNode iVisited) {
+ for (RubyLintVisitor visitor : visitors) {
+ visitor.visitCallNode(iVisited);
+ }
+ return super.visitCallNode(iVisited);
+ }
+
+ @Override
+ public Instruction visitCaseNode(CaseNode iVisited) {
+ for (RubyLintVisitor visitor : visitors) {
+ visitor.visitCaseNode(iVisited);
+ }
+ return super.visitCaseNode(iVisited);
+ }
+
+ @Override
+ public Instruction visitClassNode(ClassNode iVisited) {
+ for (RubyLintVisitor visitor : visitors) {
+ visitor.visitClassNode(iVisited);
+ }
+ Instruction ins = super.visitClassNode(iVisited);
+ for (RubyLintVisitor visitor : visitors) {
+ visitor.exitClassNode(iVisited);
+ }
+ return ins;
+ }
+
+ @Override
+ public Instruction visitClassVarAsgnNode(ClassVarAsgnNode iVisited) {
+ for (RubyLintVisitor visitor : visitors) {
+ visitor.visitClassVarAsgnNode(iVisited);
+ }
+ return super.visitClassVarAsgnNode(iVisited);
+ }
+
+ @Override
+ public Instruction visitClassVarDeclNode(ClassVarDeclNode iVisited) {
+ for (RubyLintVisitor visitor : visitors) {
+ visitor.visitClassVarDeclNode(iVisited);
+ }
+ return super.visitClassVarDeclNode(iVisited);
+ }
+
+ @Override
+ public Instruction visitClassVarNode(ClassVarNode iVisited) {
+ for (RubyLintVisitor visitor : visitors) {
+ visitor.visitClassVarNode(iVisited);
+ }
+ return super.visitClassVarNode(iVisited);
+ }
+
+ @Override
+ public Instruction visitColon2Node(Colon2Node iVisited) {
+ for (RubyLintVisitor visitor : visitors) {
+ visitor.visitColon2Node(iVisited);
+ }
+ return super.visitColon2Node(iVisited);
+ }
+
+ @Override
+ public Instruction visitColon3Node(Colon3Node iVisited) {
+ for (RubyLintVisitor visitor : visitors) {
+ visitor.visitColon3Node(iVisited);
+ }
+ return super.visitColon3Node(iVisited);
+ }
+
+ @Override
+ public Instruction visitConstDeclNode(ConstDeclNode iVisited) {
+ for (RubyLintVisitor visitor : visitors) {
+ visitor.visitConstDeclNode(iVisited);
+ }
+ return super.visitConstDeclNode(iVisited);
+ }
+
+ @Override
+ public Instruction visitConstNode(ConstNode iVisited) {
+ for (RubyLintVisitor visitor : visitors) {
+ visitor.visitConstNode(iVisited);
+ }
+ return super.visitConstNode(iVisited);
+ }
+
+ @Override
+ public Instruction visitDAsgnNode(DAsgnNode iVisited) {
+ for (RubyLintVisitor visitor : visitors) {
+ visitor.visitDAsgnNode(iVisited);
+ }
+ return super.visitDAsgnNode(iVisited);
+ }
+
+ @Override
+ public Instruction visitDefinedNode(DefinedNode iVisited) {
+ for (RubyLintVisitor visitor : visitors) {
+ visitor.visitDefinedNode(iVisited);
+ }
+ return super.visitDefinedNode(iVisited);
+ }
+
+ @Override
+ public Instruction visitDefnNode(DefnNode iVisited) {
+ for (RubyLintVisitor visitor : visitors) {
+ visitor.visitDefnNode(iVisited);
+ }
+ Instruction ins = super.visitDefnNode(iVisited);
+ for (RubyLintVisitor visitor : visitors) {
+ visitor.exitDefnNode(iVisited);
+ }
+ return ins;
+ }
+
+ @Override
+ public Instruction visitDefsNode(DefsNode iVisited) {
+ for (RubyLintVisitor visitor : visitors) {
+ visitor.visitDefsNode(iVisited);
+ }
+ Instruction ins = super.visitDefsNode(iVisited);
+ for (RubyLintVisitor visitor : visitors) {
+ visitor.exitDefsNode(iVisited);
+ }
+ return ins;
+ }
+
+
+ @Override
+ public Instruction visitDotNode(DotNode iVisited) {
+ for (RubyLintVisitor visitor : visitors) {
+ visitor.visitDotNode(iVisited);
+ }
+ return super.visitDotNode(iVisited);
+ }
+
+ @Override
+ public Instruction visitDRegxNode(DRegexpNode iVisited) {
+ for (RubyLintVisitor visitor : visitors) {
+ visitor.visitDRegxNode(iVisited);
+ }
+ return super.visitDRegxNode(iVisited);
+ }
+
+ @Override
+ public Instruction visitDStrNode(DStrNode iVisited) {
+ for (RubyLintVisitor visitor : visitors) {
+ visitor.visitDStrNode(iVisited);
+ }
+ return super.visitDStrNode(iVisited);
+ }
+
+ @Override
+ public Instruction visitDSymbolNode(DSymbolNode iVisited) {
+ for (RubyLintVisitor visitor : visitors) {
+ visitor.visitDSymbolNode(iVisited);
+ }
+ return super.visitDSymbolNode(iVisited);
+ }
+
+ @Override
+ public Instruction visitDVarNode(DVarNode iVisited) {
+ for (RubyLintVisitor visitor : visitors) {
+ visitor.visitDVarNode(iVisited);
+ }
+ return super.visitDVarNode(iVisited);
+ }
+
+ @Override
+ public Instruction visitDXStrNode(DXStrNode iVisited) {
+ for (RubyLintVisitor visitor : visitors) {
+ visitor.visitDXStrNode(iVisited);
+ }
+ return super.visitDXStrNode(iVisited);
+ }
+
+ @Override
+ public Instruction visitEnsureNode(EnsureNode iVisited) {
+ for (RubyLintVisitor visitor : visitors) {
+ visitor.visitEnsureNode(iVisited);
+ }
+ return super.visitEnsureNode(iVisited);
+ }
+
+ @Override
+ public Instruction visitEvStrNode(EvStrNode iVisited) {
+ for (RubyLintVisitor visitor : visitors) {
+ visitor.visitEvStrNode(iVisited);
+ }
+ return super.visitEvStrNode(iVisited);
+ }
+
+ @Override
+ public Instruction visitFalseNode(FalseNode iVisited) {
+ for (RubyLintVisitor visitor : visitors) {
+ visitor.visitFalseNode(iVisited);
+ }
+ return super.visitFalseNode(iVisited);
+ }
+
+ @Override
+ public Instruction visitFCallNode(FCallNode iVisited) {
+ for (RubyLintVisitor visitor : visitors) {
+ visitor.visitFCallNode(iVisited);
+ }
+ return super.visitFCallNode(iVisited);
+ }
+
+ @Override
+ public Instruction visitFixnumNode(FixnumNode iVisited) {
+ for (RubyLintVisitor visitor : visitors) {
+ visitor.visitFixnumNode(iVisited);
+ }
+ return super.visitFixnumNode(iVisited);
+ }
+
+ @Override
+ public Instruction visitFlipNode(FlipNode iVisited) {
+ for (RubyLintVisitor visitor : visitors) {
+ visitor.visitFlipNode(iVisited);
+ }
+ return super.visitFlipNode(iVisited);
+ }
+
+ @Override
+ public Instruction visitFloatNode(FloatNode iVisited) {
+ for (RubyLintVisitor visitor : visitors) {
+ visitor.visitFloatNode(iVisited);
+ }
+ return super.visitFloatNode(iVisited);
+ }
+
+ @Override
+ public Instruction visitForNode(ForNode iVisited) {
+ for (RubyLintVisitor visitor : visitors) {
+ visitor.visitForNode(iVisited);
+ }
+ return super.visitForNode(iVisited);
+ }
+
+ @Override
+ public Instruction visitGlobalAsgnNode(GlobalAsgnNode iVisited) {
+ for (RubyLintVisitor visitor : visitors) {
+ visitor.visitGlobalAsgnNode(iVisited);
+ }
+ return super.visitGlobalAsgnNode(iVisited);
+ }
+
+ @Override
+ public Instruction visitGlobalVarNode(GlobalVarNode iVisited) {
+ for (RubyLintVisitor visitor : visitors) {
+ visitor.visitGlobalVarNode(iVisited);
+ }
+ return super.visitGlobalVarNode(iVisited);
+ }
+
+ @Override
+ public Instruction visitHashNode(HashNode iVisited) {
+ for (RubyLintVisitor visitor : visitors) {
+ visitor.visitHashNode(iVisited);
+ }
+ return super.visitHashNode(iVisited);
+ }
+
+ @Override
+ public Instruction visitIfNode(IfNode iVisited) {
+ for (RubyLintVisitor visitor : visitors) {
+ visitor.visitIfNode(iVisited);
+ }
+ Instruction ins = super.visitIfNode(iVisited);
+ for (RubyLintVisitor visitor : visitors) {
+ visitor.exitIfNode(iVisited);
+ }
+ return ins;
+ }
+
+ @Override
+ public Instruction visitInstAsgnNode(InstAsgnNode iVisited) {
+ for (RubyLintVisitor visitor : visitors) {
+ visitor.visitInstAsgnNode(iVisited);
+ }
+ return super.visitInstAsgnNode(iVisited);
+ }
+
+ @Override
+ public Instruction visitInstVarNode(InstVarNode iVisited) {
+ for (RubyLintVisitor visitor : visitors) {
+ visitor.visitInstVarNode(iVisited);
+ }
+ return super.visitInstVarNode(iVisited);
+ }
+
+ @Override
+ public Instruction visitIterNode(IterNode iVisited) {
+ for (RubyLintVisitor visitor : visitors) {
+ visitor.visitIterNode(iVisited);
+ }
+ return super.visitIterNode(iVisited);
+ }
+
+ @Override
+ public Instruction visitLocalAsgnNode(LocalAsgnNode iVisited) {
+ for (RubyLintVisitor visitor : visitors) {
+ visitor.visitLocalAsgnNode(iVisited);
+ }
+ return super.visitLocalAsgnNode(iVisited);
+ }
+
+ @Override
+ public Instruction visitLocalVarNode(LocalVarNode iVisited) {
+ for (RubyLintVisitor visitor : visitors) {
+ visitor.visitLocalVarNode(iVisited);
+ }
+ return super.visitLocalVarNode(iVisited);
+ }
+
+ @Override
+ public Instruction visitMatch2Node(Match2Node iVisited) {
+ for (RubyLintVisitor visitor : visitors) {
+ visitor.visitMatch2Node(iVisited);
+ }
+ return super.visitMatch2Node(iVisited);
+ }
+
+ @Override
+ public Instruction visitMatch3Node(Match3Node iVisited) {
+ for (RubyLintVisitor visitor : visitors) {
+ visitor.visitMatch3Node(iVisited);
+ }
+ return super.visitMatch3Node(iVisited);
+ }
+
+ @Override
+ public Instruction visitMatchNode(MatchNode iVisited) {
+ for (RubyLintVisitor visitor : visitors) {
+ visitor.visitMatchNode(iVisited);
+ }
+ return super.visitMatchNode(iVisited);
+ }
+
+ @Override
+ public Instruction visitModuleNode(ModuleNode iVisited) {
+ for (RubyLintVisitor visitor : visitors) {
+ visitor.visitModuleNode(iVisited);
+ }
+ Instruction ins = super.visitModuleNode(iVisited);
+ for (RubyLintVisitor visitor : visitors) {
+ visitor.exitModuleNode(iVisited);
+ }
+ return ins;
+ }
+
+ @Override
+ public Instruction visitMultipleAsgnNode(MultipleAsgnNode iVisited) {
+ for (RubyLintVisitor visitor : visitors) {
+ visitor.visitMultipleAsgnNode(iVisited);
+ }
+ return super.visitMultipleAsgnNode(iVisited);
+ }
+
+ @Override
+ public Instruction visitNewlineNode(NewlineNode iVisited) {
+ for (RubyLintVisitor visitor : visitors) {
+ visitor.visitNewlineNode(iVisited);
+ }
+ return super.visitNewlineNode(iVisited);
+ }
+
+ @Override
+ public Instruction visitNextNode(NextNode iVisited) {
+ for (RubyLintVisitor visitor : visitors) {
+ visitor.visitNextNode(iVisited);
+ }
+ return super.visitNextNode(iVisited);
+ }
+
+ @Override
+ public Instruction visitNilNode(NilNode iVisited) {
+ for (RubyLintVisitor visitor : visitors) {
+ visitor.visitNilNode(iVisited);
+ }
+ return super.visitNilNode(iVisited);
+ }
+
+ @Override
+ public Instruction visitNotNode(NotNode iVisited) {
+ for (RubyLintVisitor visitor : visitors) {
+ visitor.visitNotNode(iVisited);
+ }
+ return super.visitNotNode(iVisited);
+ }
+
+ @Override
+ public Instruction visitNthRefNode(NthRefNode iVisited) {
+ for (RubyLintVisitor visitor : visitors) {
+ visitor.visitNthRefNode(iVisited);
+ }
+ return super.visitNthRefNode(iVisited);
+ }
+
+ @Override
+ public Instruction visitOpAsgnAndNode(OpAsgnAndNode iVisited) {
+ for (RubyLintVisitor visitor : visitors) {
+ visitor.visitOpAsgnAndNode(iVisited);
+ }
+ return super.visitOpAsgnAndNode(iVisited);
+ }
+
+ @Override
+ public Instruction visitOpAsgnNode(OpAsgnNode iVisited) {
+ for (RubyLintVisitor visitor : visitors) {
+ visitor.visitOpAsgnNode(iVisited);
+ }
+ return super.visitOpAsgnNode(iVisited);
+ }
+
+ @Override
+ public Instruction visitOpAsgnOrNode(OpAsgnOrNode iVisited) {
+ for (RubyLintVisitor visitor : visitors) {
+ visitor.visitOpAsgnOrNode(iVisited);
+ }
+ return super.visitOpAsgnOrNode(iVisited);
+ }
+
+ @Override
+ public Instruction visitOpElementAsgnNode(OpElementAsgnNode iVisited) {
+ for (RubyLintVisitor visitor : visitors) {
+ visitor.visitOpElementAsgnNode(iVisited);
+ }
+ return super.visitOpElementAsgnNode(iVisited);
+ }
+
+ @Override
+ public Instruction visitOptNNode(OptNNode iVisited) {
+ for (RubyLintVisitor visitor : visitors) {
+ visitor.visitOptNNode(iVisited);
+ }
+ return super.visitOptNNode(iVisited);
+ }
+
+ @Override
+ public Instruction visitOrNode(OrNode iVisited) {
+ for (RubyLintVisitor visitor : visitors) {
+ visitor.visitOrNode(iVisited);
+ }
+ return super.visitOrNode(iVisited);
+ }
+
+ @Override
+ public Instruction visitPostExeNode(PostExeNode iVisited) {
+ for (RubyLintVisitor visitor : visitors) {
+ visitor.visitPostExeNode(iVisited);
+ }
+ return super.visitPostExeNode(iVisited);
+ }
+
+ @Override
+ public Instruction visitRedoNode(RedoNode iVisited) {
+ for (RubyLintVisitor visitor : visitors) {
+ visitor.visitRedoNode(iVisited);
+ }
+ return super.visitRedoNode(iVisited);
+ }
+
+ @Override
+ public Instruction visitRegexpNode(RegexpNode iVisited) {
+ for (RubyLintVisitor visitor : visitors) {
+ visitor.visitRegexpNode(iVisited);
+ }
+ return super.visitRegexpNode(iVisited);
+ }
+
+ @Override
+ public Instruction visitRescueBodyNode(RescueBodyNode iVisited) {
+ for (RubyLintVisitor visitor : visitors) {
+ visitor.visitRescueBodyNode(iVisited);
+ }
+ return super.visitRescueBodyNode(iVisited);
+ }
+
+ @Override
+ public Instruction visitRescueNode(RescueNode iVisited) {
+ for (RubyLintVisitor visitor : visitors) {
+ visitor.visitRescueNode(iVisited);
+ }
+ return super.visitRescueNode(iVisited);
+ }
+
+ @Override
+ public Instruction visitRetryNode(RetryNode iVisited) {
+ for (RubyLintVisitor visitor : visitors) {
+ visitor.visitRetryNode(iVisited);
+ }
+ return super.visitRetryNode(iVisited);
+ }
+
+ @Override
+ public Instruction visitReturnNode(ReturnNode iVisited) {
+ for (RubyLintVisitor visitor : visitors) {
+ visitor.visitReturnNode(iVisited);
+ }
+ return super.visitReturnNode(iVisited);
+ }
+
+ @Override
+ public Instruction visitRootNode(RootNode iVisited) {
+ for (RubyLintVisitor visitor : visitors) {
+ visitor.visitRootNode(iVisited);
+ }
+ return super.visitRootNode(iVisited);
+ }
+
+ @Override
+ public Instruction visitSClassNode(SClassNode iVisited) {
+ for (RubyLintVisitor visitor : visitors) {
+ visitor.visitSClassNode(iVisited);
+ }
+ Instruction ins = super.visitSClassNode(iVisited);
+ for (RubyLintVisitor visitor : visitors) {
+ visitor.exitSClassNode(iVisited);
+ }
+ return ins;
+ }
+
+ @Override
+ public Instruction visitSelfNode(SelfNode iVisited) {
+ for (RubyLintVisitor visitor : visitors) {
+ visitor.visitSelfNode(iVisited);
+ }
+ return super.visitSelfNode(iVisited);
+ }
+
+ @Override
+ public Instruction visitSplatNode(SplatNode iVisited) {
+ for (RubyLintVisitor visitor : visitors) {
+ visitor.visitSplatNode(iVisited);
+ }
+ return super.visitSplatNode(iVisited);
+ }
+
+ @Override
+ public Instruction visitStrNode(StrNode iVisited) {
+ for (RubyLintVisitor visitor : visitors) {
+ visitor.visitStrNode(iVisited);
+ }
+ return super.visitStrNode(iVisited);
+ }
+
+ @Override
+ public Instruction visitSuperNode(SuperNode iVisited) {
+ for (RubyLintVisitor visitor : visitors) {
+ visitor.visitSuperNode(iVisited);
+ }
+ return super.visitSuperNode(iVisited);
+ }
+
+ @Override
+ public Instruction visitSValueNode(SValueNode iVisited) {
+ for (RubyLintVisitor visitor : visitors) {
+ visitor.visitSValueNode(iVisited);
+ }
+ return super.visitSValueNode(iVisited);
+ }
+
+ @Override
+ public Instruction visitSymbolNode(SymbolNode iVisited) {
+ for (RubyLintVisitor visitor : visitors) {
+ visitor.visitSymbolNode(iVisited);
+ }
+ return super.visitSymbolNode(iVisited);
+ }
+
+ @Override
+ public Instruction visitToAryNode(ToAryNode iVisited) {
+ for (RubyLintVisitor visitor : visitors) {
+ visitor.visitToAryNode(iVisited);
+ }
+ return super.visitToAryNode(iVisited);
+ }
+
+ @Override
+ public Instruction visitTrueNode(TrueNode iVisited) {
+ for (RubyLintVisitor visitor : visitors) {
+ visitor.visitTrueNode(iVisited);
+ }
+ return super.visitTrueNode(iVisited);
+ }
+
+ @Override
+ public Instruction visitUndefNode(UndefNode iVisited) {
+ for (RubyLintVisitor visitor : visitors) {
+ visitor.visitUndefNode(iVisited);
+ }
+ return super.visitUndefNode(iVisited);
+ }
+
+ @Override
+ public Instruction visitUntilNode(UntilNode iVisited) {
+ for (RubyLintVisitor visitor : visitors) {
+ visitor.visitUntilNode(iVisited);
+ }
+ return super.visitUntilNode(iVisited);
+ }
+
+ @Override
+ public Instruction visitVAliasNode(VAliasNode iVisited) {
+ for (RubyLintVisitor visitor : visitors) {
+ visitor.visitVAliasNode(iVisited);
+ }
+ return super.visitVAliasNode(iVisited);
+ }
+
+ @Override
+ public Instruction visitVCallNode(VCallNode iVisited) {
+ for (RubyLintVisitor visitor : visitors) {
+ visitor.visitVCallNode(iVisited);
+ }
+ return super.visitVCallNode(iVisited);
+ }
+
+ @Override
+ public Instruction visitWhenNode(WhenNode iVisited) {
+ for (RubyLintVisitor visitor : visitors) {
+ visitor.visitWhenNode(iVisited);
+ }
+ Instruction ins = super.visitWhenNode(iVisited);
+ for (RubyLintVisitor visitor : visitors) {
+ visitor.exitWhenNode(iVisited);
+ }
+ return ins;
+ }
+
+ @Override
+ public Instruction visitWhileNode(WhileNode iVisited) {
+ for (RubyLintVisitor visitor : visitors) {
+ visitor.visitWhileNode(iVisited);
+ }
+ return super.visitWhileNode(iVisited);
+ }
+
+ @Override
+ public Instruction visitXStrNode(XStrNode iVisited) {
+ for (RubyLintVisitor visitor : visitors) {
+ visitor.visitXStrNode(iVisited);
+ }
+ return super.visitXStrNode(iVisited);
+ }
+
+ @Override
+ public Instruction visitYieldNode(YieldNode iVisited) {
+ for (RubyLintVisitor visitor : visitors) {
+ visitor.visitYieldNode(iVisited);
+ }
+ return super.visitYieldNode(iVisited);
+ }
+
+ @Override
+ public Instruction visitZArrayNode(ZArrayNode iVisited) {
+ for (RubyLintVisitor visitor : visitors) {
+ visitor.visitZArrayNode(iVisited);
+ }
+ return super.visitZArrayNode(iVisited);
+ }
+
+ @Override
+ public Instruction visitZSuperNode(ZSuperNode iVisited) {
+ for (RubyLintVisitor visitor : visitors) {
+ visitor.visitZSuperNode(iVisited);
+ }
+ return super.visitZSuperNode(iVisited);
+ }
+
+}
\ No newline at end of file
Copied: trunk/org.rubypeople.rdt.core/src/org/rubypeople/rdt/core/parser/warnings/RubyLintVisitor.java (from rev 2923, trunk/org.rubypeople.rdt.core/src/org/rubypeople/rdt/internal/core/parser/warnings/RubyLintVisitor.java)
===================================================================
--- trunk/org.rubypeople.rdt.core/src/org/rubypeople/rdt/core/parser/warnings/RubyLintVisitor.java (rev 0)
+++ trunk/org.rubypeople.rdt.core/src/org/rubypeople/rdt/core/parser/warnings/RubyLintVisitor.java 2007-08-09 14:21:16 UTC (rev 2952)
@@ -0,0 +1,136 @@
+package org.rubypeople.rdt.core.parser.warnings;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+
+import org.jruby.ast.BlockNode;
+import org.jruby.ast.ClassNode;
+import org.jruby.ast.DefnNode;
+import org.jruby.ast.DefsNode;
+import org.jruby.ast.IfNode;
+import org.jruby.ast.ModuleNode;
+import org.jruby.ast.Node;
+import org.jruby.ast.SClassNode;
+import org.jruby.ast.WhenNode;
+import org.jruby.ast.visitor.AbstractVisitor;
+import org.jruby.evaluator.Instruction;
+import org.jruby.lexer.yacc.ISourcePosition;
+import org.rubypeople.rdt.core.RubyCore;
+import org.rubypeople.rdt.core.compiler.CategorizedProblem;
+import org.rubypeople.rdt.core.compiler.IProblem;
+import org.rubypeople.rdt.internal.core.parser.Error;
+import org.rubypeople.rdt.internal.core.parser.Warning;
+import org.rubypeople.rdt.internal.core.util.ASTUtil;
+
+public abstract class RubyLintVisitor extends AbstractVisitor {
+
+ private String contents;
+ protected Map fOptions;
+ private List<CategorizedProblem> problems;
+
+ public RubyLintVisitor(String contents) {
+ this(RubyCore.getOptions(), contents);
+ }
+
+ public RubyLintVisitor(Map options, String contents) {
+ this.problems = new ArrayList<CategorizedProblem>();
+ this.contents = contents;
+ this.fOptions = options;
+ }
+
+ protected String getSource(Node node) {
+ return ASTUtil.getSource(contents, node);
+ }
+
+ public List<CategorizedProblem> getProblems() {
+ return problems;
+ }
+
+ public boolean isIgnored() {
+ String value = getSeverity();
+ if (value != null && value.equals(RubyCore.IGNORE))
+ return true;
+ return false;
+ }
+
+ protected void createProblem(ISourcePosition position, String message) {
+ String value = getSeverity();
+ if (value != null && value.equals(RubyCore.IGNORE))
+ return;
+ CategorizedProblem problem;
+ if (value != null && value.equals(RubyCore.ERROR))
+ problem = new Error(position, message, getProblemID());
+ else
+ problem = new Warning(position, message, getProblemID());
+ problems.add(problem);
+ }
+
+ protected String getSeverity() {
+ return (String) fOptions.get(getOptionKey());
+ }
+
+ @Override
+ protected Instruction visitNode(Node iVisited) {
+ return null;
+ }
+
+ /**
+ * The key used to store the error/warning severity option.
+ * @return a String key
+ */
+ abstract protected String getOptionKey();
+
+ /**
+ * Meant to be overriden by classes needing to perform some action when a class definition was exited.
+ * @param iVisited
+ */
+ public void exitClassNode(ClassNode iVisited) {}
+
+ /**
+ * To be overriden by subclasses who need to run particular behavior/code when exiting a method definition.
+ * @param iVisited
+ */
+ public void exitDefnNode(DefnNode iVisited) {}
+
+ /**
+ * To be overriden by subclasses who need to run particular behavior/code when exiting a singleton method definition.
+ * @param iVisited
+ */
+ public void exitIfNode(IfNode iVisited) {}
+
+ /**
+ * To be overriden by subclasses who need to run particular behavior/code when exiting a singleton method definition.
+ * @param iVisited
+ */
+ public void exitBlockNode(BlockNode iVisited) {}
+
+ /**
+ * To be overriden by subclasses who need to run particular behavior/code when exiting a singleton method definition.
+ * @param iVisited
+ */
+ public void exitDefsNode(DefsNode iVisited) {}
+
+ /**
+ * To be overriden by subclasses who need to run particular behavior/code when exiting a singleton method definition.
+ * @param iVisited
+ */
+ public void exitModuleNode(ModuleNode iVisited) {}
+
+ /**
+ * To be overriden by subclasses who need to run particular behavior/code when exiting a singleton method definition.
+ * @param iVisited
+ */
+ public void exitWhenNode(WhenNode iVisited) {}
+
+ /**
+ * To be overriden by subclasses who need to run particular behavior/code when exiting a singleton method definition.
+ * @param iVisited
+ */
+ public void exitSClassNode(SClassNode iVisited) {}
+
+ protected int getProblemID() {
+ return IProblem.Uncategorized;
+ }
+
+}
Modified: trunk/org.rubypeople.rdt.core/src/org/rubypeople/rdt/internal/core/RubyScriptProblemFinder.java
===================================================================
--- trunk/org.rubypeople.rdt.core/src/org/rubypeople/rdt/internal/core/RubyScriptProblemFinder.java 2007-08-09 14:18:53 UTC (rev 2951)
+++ trunk/org.rubypeople.rdt.core/src/org/rubypeople/rdt/internal/core/RubyScriptProblemFinder.java 2007-08-09 14:21:16 UTC (rev 2952)
@@ -16,13 +16,13 @@
import org.rubypeople.rdt.core.RubyCore;
import org.rubypeople.rdt.core.RubyModelException;
import org.rubypeople.rdt.core.compiler.CategorizedProblem;
+import org.rubypeople.rdt.core.parser.warnings.DelegatingVisitor;
+import org.rubypeople.rdt.core.parser.warnings.RubyLintVisitor;
import org.rubypeople.rdt.internal.core.parser.Error;
import org.rubypeople.rdt.internal.core.parser.RdtWarnings;
import org.rubypeople.rdt.internal.core.parser.RubyParser;
import org.rubypeople.rdt.internal.core.parser.TaskParser;
import org.rubypeople.rdt.internal.core.parser.TaskTag;
-import org.rubypeople.rdt.internal.core.parser.warnings.DelegatingVisitor;
-import org.rubypeople.rdt.internal.core.parser.warnings.RubyLintVisitor;
/**
* @author Chris
Modified: trunk/org.rubypeople.rdt.core/src/org/rubypeople/rdt/internal/core/builder/RubyCodeAnalyzer.java
===================================================================
--- trunk/org.rubypeople.rdt.core/src/org/rubypeople/rdt/internal/core/builder/RubyCodeAnalyzer.java 2007-08-09 14:18:53 UTC (rev 2951)
+++ trunk/org.rubypeople.rdt.core/src/org/rubypeople/rdt/internal/core/builder/RubyCodeAnalyzer.java 2007-08-09 14:21:16 UTC (rev 2952)
@@ -25,11 +25,11 @@
import org.jruby.ast.visitor.NodeVisitor;
import org.jruby.lexer.yacc.SyntaxException;
import org.rubypeople.rdt.core.RubyCore;
+import org.rubypeople.rdt.core.parser.warnings.DelegatingVisitor;
+import org.rubypeople.rdt.core.parser.warnings.RubyLintVisitor;
import org.rubypeople.rdt.internal.core.parser.Error;
import org.rubypeople.rdt.internal.core.parser.ImmediateWarnings;
import org.rubypeople.rdt.internal.core.parser.RubyParser;
-import org.rubypeople.rdt.internal.core.parser.warnings.DelegatingVisitor;
-import org.rubypeople.rdt.internal.core.parser.warnings.RubyLintVisitor;
public final class RubyCodeAnalyzer implements SingleFileCompiler {
private final IMarkerManager markerManager;
Modified: trunk/org.rubypeople.rdt.core/src/org/rubypeople/rdt/internal/core/parser/warnings/ConstantReassignmentVisitor.java
===================================================================
--- trunk/org.rubypeople.rdt.core/src/org/rubypeople/rdt/internal/core/parser/warnings/ConstantReassignmentVisitor.java 2007-08-09 14:18:53 UTC (rev 2951)
+++ trunk/org.rubypeople.rdt.core/src/org/rubypeople/rdt/internal/core/parser/warnings/ConstantReassignmentVisitor.java 2007-08-09 14:21:16 UTC (rev 2952)
@@ -6,6 +6,7 @@
import org.jruby.ast.ConstDeclNode;
import org.jruby.evaluator.Instruction;
import org.rubypeople.rdt.core.RubyCore;
+import org.rubypeople.rdt.core.parser.warnings.RubyLintVisitor;
public class ConstantReassignmentVisitor extends RubyLintVisitor {
Deleted: trunk/org.rubypeople.rdt.core/src/org/rubypeople/rdt/internal/core/parser/warnings/DelegatingVisitor.java
===================================================================
--- trunk/org.rubypeople.rdt.core/src/org/rubypeople/rdt/internal/core/parser/warnings/DelegatingVisitor.java 2007-08-09 14:18:53 UTC (rev 2951)
+++ trunk/org.rubypeople.rdt.core/src/org/rubypeople/rdt/internal/core/parser/warnings/DelegatingVisitor.java 2007-08-09 14:21:16 UTC (rev 2952)
@@ -1,926 +0,0 @@
-package org.rubypeople.rdt.internal.core.parser.warnings;
-
-import java.util.ArrayList;
-import java.util.List;
-
-import org.jruby.ast.AliasNode;
-import org.jruby.ast.AndNode;
-import org.jruby.ast.ArgsCatNode;
-import org.jruby.ast.ArgsNode;
-import org.jruby.ast.ArgsPushNode;
-import org.jruby.ast.ArrayNode;
-import org.jruby.ast.AttrAssignNode;
-import org.jruby.ast.BackRefNode;
-import org.jruby.ast.BeginNode;
-import org.jruby.ast.BignumNode;
-import org.jruby.ast.BlockArgNode;
-import org.jruby.ast.BlockNode;
-import org.jruby.ast.BlockPassNode;
-import org.jruby.ast.BreakNode;
-import org.jruby.ast.CallNode;
-import org.jruby.ast.CaseNode;
-import org.jruby.ast.ClassNode;
-import org.jruby.ast.ClassVarAsgnNode;
-import org.jruby.ast.ClassVarDeclNode;
-import org.jruby.ast.ClassVarNode;
-import org.jruby.ast.Colon2Node;
-import org.jruby.ast.Colon3Node;
-import org.jruby.ast.ConstDeclNode;
-import org.jruby.ast.ConstNode;
-import org.jruby.ast.DAsgnNode;
-import org.jruby.ast.DRegexpNode;
-import org.jruby.ast.DStrNode;
-import org.jruby.ast.DSymbolNode;
-import org.jruby.ast.DVarNode;
-import org.jruby.ast.DXStrNode;
-import org.jruby.ast.DefinedNode;
-import org.jruby.ast.DefnNode;
-import org.jruby.ast.DefsNode;
-import org.jruby.ast.DotNode;
-import org.jruby.ast.EnsureNode;
-import org.jruby.ast.EvStrNode;
-import org.jruby.ast.FCallNode;
-import org.jruby.ast.FalseNode;
-import org.jruby.ast.FixnumNode;
-import org.jruby.ast.FlipNode;
-import org.jruby.ast.FloatNode;
-import org.jruby.ast.ForNode;
-import org.jruby.ast.GlobalAsgnNode;
-import org.jruby.ast.GlobalVarNode;
-import org.jruby.ast.HashNode;
-import org.jruby.ast.IfNode;
-import org.jruby.ast.InstAsgnNode;
-import org.jruby.ast.InstVarNode;
-import org.jruby.ast.IterNode;
-import org.jruby.ast.LocalAsgnNode;
-import org.jruby.ast.LocalVarNode;
-import org.jruby.ast.Match2Node;
-import org.jruby.ast.Match3Node;
-import org.jruby.ast.MatchNode;
-import org.jruby.ast.ModuleNode;
-import org.jruby.ast.MultipleAsgnNode;
-import org.jruby.ast.NewlineNode;
-import org.jruby.ast.NextNode;
-import org.jruby.ast.NilNode;
-import org.jruby.ast.NotNode;
-import org.jruby.ast.NthRefNode;
-import org.jruby.ast.OpAsgnAndNode;
-import org.jruby.ast.OpAsgnNode;
-import org.jruby.ast.OpAsgnOrNode;
-import org.jruby.ast.OpElementAsgnNode;
-import org.jruby.ast.OptNNode;
-import org.jruby.ast.OrNode;
-import org.jruby.ast.PostExeNode;
-import org.jruby.ast.RedoNode;
-import org.jruby.ast.RegexpNode;
-import org.jruby.ast.RescueBodyNode;
-import org.jruby.ast.RescueNode;
-import org.jruby.ast.RetryNode;
-import org.jruby.ast.ReturnNode;
-import org.jruby.ast.RootNode;
-import org.jruby.ast.SClassNode;
-import org.jruby.ast.SValueNode;
-import org.jruby.ast.SelfNode;
-import org.jruby.ast.SplatNode;
-import org.jruby.ast.StrNode;
-import org.jruby.ast.SuperNode;
-import org.jruby.ast.SymbolNode;
-import org.jruby.ast.ToAryNode;
-import org.jruby.ast.TrueNode;
-import org.jruby.ast.UndefNode;
-import org.jruby.ast.UntilNode;
-import org.jruby.ast.VAliasNode;
-import org.jruby.ast.VCallNode;
-import org.jruby.ast.WhenNode;
-import org.jruby.ast.WhileNode;
-import org.jruby.ast.XStrNode;
-import org.jruby.ast.YieldNode;
-import org.jruby.ast.ZArrayNode;
-import org.jruby.ast.ZSuperNode;
-import org.jruby.evaluator.Instruction;
-import org.rubypeople.rdt.core.compiler.CategorizedProblem;
-import org.rubypeople.rdt.internal.core.parser.InOrderVisitor;
-
-/**
- * <p>DelegatingVisitor takes a list of visitors, traverse the AST in order, and at
- * each node calls the correct visitXXXNode method on every visitor. This allows
- * us to traverse the AST only once while having X number of visitors operate on
- * it.</p>
- *
- * <p>Right now it is customized to RubyLintVisitors, which is the abstract
- * base class for all visitors that do coce analysis for Error/Warning markers.</p>
- *
- * @author Christopher Williams
- *
- */
-public class DelegatingVisitor extends InOrderVisitor {
-
- private List<RubyLintVisitor> visitors;
-
- public static List<RubyLintVisitor> createVisitors(String contents) {
- List<RubyLintVisitor> visitors = new ArrayList<RubyLintVisitor>();
- // FIXME Run through a map of keys to classes and add instances of
- // classes whose key is not set to ignore
- visitors.add(new EmptyStatementVisitor(contents));
- visitors.add(new ConstantReassignmentVisitor(contents));
- return visitors;
- }
-
- public List<CategorizedProblem> getProblems() {
- List<CategorizedProblem> problems = new ArrayList<CategorizedProblem>();
- for (RubyLintVisitor visitor : visitors) {
- problems.addAll(visitor.getProblems());
- }
- return problems;
- }
-
- public DelegatingVisitor(List<RubyLintVisitor> visitors) {
- this.visitors = visitors;
- }
-
- @Override
- public Instruction visitAliasNode(AliasNode iVisited) {
- for (RubyLintVisitor visitor : visitors) {
- visitor.visitAliasNode(iVisited);
- }
- return super.visitAliasNode(iVisited);
- }
-
- @Override
- public Instruction visitAndNode(AndNode iVisited) {
- for (RubyLintVisitor visitor : visitors) {
- visitor.visitAndNode(iVisited);
- }
- return super.visitAndNode(iVisited);
- }
-
- @Override
- public Instruction visitArgsCatNode(ArgsCatNode iVisited) {
- for (RubyLintVisitor visitor : visitors) {
- visitor.visitArgsCatNode(iVisited);
- }
- return super.visitArgsCatNode(iVisited);
- }
-
- @Override
- public Instruction visitArgsNode(ArgsNode iVisited) {
- for (RubyLintVisitor visitor : visitors) {
- visitor.visitArgsNode(iVisited);
- }
- return super.visitArgsNode(iVisited);
- }
-
- @Override
- public Instruction visitArgsPushNode(ArgsPushNode iVisited) {
- for (RubyLintVisitor visitor : visitors) {
- visitor.visitArgsPushNode(iVisited);
- }
- return super.visitArgsPushNode(iVisited);
- }
-
- @Override
- public Instruction visitArrayNode(ArrayNode iVisited) {
- for (RubyLintVisitor visitor : visitors) {
- visitor.visitArrayNode(iVisited);
- }
- return super.visitArrayNode(iVisited);
- }
-
- @Override
- public Instruction visitAttrAssignNode(AttrAssignNode iVisited) {
- for (RubyLintVisitor visitor : visitors) {
- visitor.visitAttrAssignNode(iVisited);
- }
- return super.visitAttrAssignNode(iVisited);
- }
-
- @Override
- public Instruction visitBackRefNode(BackRefNode iVisited) {
- for (RubyLintVisitor visitor : visitors) {
- visitor.visitBackRefNode(iVisited);
- }
- return super.visitBackRefNode(iVisited);
- }
-
- @Override
- public Instruction visitBeginNode(BeginNode iVisited) {
- for (RubyLintVisitor visitor : visitors) {
- visitor.visitBeginNode(iVisited);
- }
- return super.visitBeginNode(iVisited);
- }
-
- @Override
- public Instruction visitBignumNode(BignumNode iVisited) {
- for (RubyLintVisitor visitor : visitors) {
- visitor.visitBignumNode(iVisited);
- }
- return super.visitBignumNode(iVisited);
- }
-
- @Override
- public Instruction visitBlockArgNode(BlockArgNode iVisited) {
- for (RubyLintVisitor visitor : visitors) {
- visitor.visitBlockArgNode(iVisited);
- }
- return super.visitBlockArgNode(iVisited);
- }
-
- @Override
- public Instruction visitBlockNode(BlockNode iVisited) {
- for (RubyLintVisitor visitor : visitors) {
- visitor.visitBlockNode(iVisited);
- }
- Instruction ins = super.visitBlockNode(iVisited);
- for (RubyLintVisitor visitor : visitors) {
- visitor.exitBlockNode(iVisited);
- }
- return ins;
- }
-
- @Override
- public Instruction visitBlockPassNode(BlockPassNode iVisited) {
- for (RubyLintVisitor visitor : visitors) {
- visitor.visitBlockPassNode(iVisited);
- }
- return super.visitBlockPassNode(iVisited);
- }
-
- @Override
- public Instruction visitBreakNode(BreakNode iVisited) {
- for (RubyLintVisitor visitor : visitors) {
- visitor.visitBreakNode(iVisited);
- }
- return super.visitBreakNode(iVisited);
- }
-
- @Override
- public Instruction visitCallNode(CallNode iVisited) {
- for (RubyLintVisitor visitor : visitors) {
- visitor.visitCallNode(iVisited);
- }
- return super.visitCallNode(iVisited);
- }
-
- @Override
- public Instruction visitCaseNode(CaseNode iVisited) {
- for (RubyLintVisitor visitor : visitors) {
- visitor.visitCaseNode(iVisited);
- }
- return super.visitCaseNode(iVisited);
- }
-
- @Override
- public Instruction visitClassNode(ClassNode iVisited) {
- for (RubyLintVisitor visitor : visitors) {
- visitor.visitClassNode(iVisited);
- }
- Instruction ins = super.visitClassNode(iVisited);
- for (RubyLintVisitor visitor : visitors) {
- visitor.exitClassNode(iVisited);
- }
- return ins;
- }
-
- @Override
- public Instruction visitClassVarAsgnNode(ClassVarAsgnNode iVisited) {
- for (RubyLintVisitor visitor : visitors) {
- visitor.visitClassVarAsgnNode(iVisited);
- }
- return super.visitClassVarAsgnNode(iVisited);
- }
-
- @Override
- public Instruction visitClassVarDeclNode(ClassVarDeclNode iVisited) {
- for (RubyLintVisitor visitor : visitors) {
- visitor.visitClassVarDeclNode(iVisited);
- }
- return super.visitClassVarDeclNode(iVisited);
- }
-
- @Override
- public Instruction visitClassVarNode(ClassVarNode iVisited) {
- for (RubyLintVisitor visitor : visitors) {
- visitor.visitClassVarNode(iVisited);
- }
- return super.visitClassVarNode(iVisited);
- }
-
- @Override
- public Instruction visitColon2Node(Colon2Node iVisited) {
- for (RubyLintVisitor visitor : visitors) {
- visitor.visitColon2Node(iVisited);
- }
- return super.visitColon2Node(iVisited);
- }
-
- @Override
- public Instruction visitColon3Node(Colon3Node iVisited) {
- for (RubyLintVisitor visitor : visitors) {
- visitor.visitColon3Node(iVisited);
- }
- return super.visitColon3Node(iVisited);
- }
-
- @Override
- public Instruction visitConstDeclNode(ConstDeclNode iVisited) {
- for (RubyLintVisitor visitor : visitors) {
- visitor.visitConstDeclNode(iVisited);
- }
- return super.visitConstDeclNode(iVisited);
- }
-
- @Override
- public Instruction visitConstNode(ConstNode iVisited) {
- for (RubyLintVisitor visitor : visitors) {
- visitor.visitConstNode(iVisited);
- }
- return super.visitConstNode(iVisited);
- }
-
- @Override
- public Instruction visitDAsgnNode(DAsgnNode iVisited) {
- for (RubyLintVisitor visitor : visitors) {
- visitor.visitDAsgnNode(iVisited);
- }
- return super.visitDAsgnNode(iVisited);
- }
-
- @Override
- public Instruction visitDefinedNode(DefinedNode iVisited) {
- for (RubyLintVisitor visitor : visitors) {
- visitor.visitDefinedNode(iVisited);
- }
- return super.visitDefinedNode(iVisited);
- }
-
- @Override
- public Instruction visitDefnNode(DefnNode iVisited) {
- for (RubyLintVisitor visitor : visitors) {
- visitor.visitDefnNode(iVisited);
- }
- Instruction ins = super.visitDefnNode(iVisited);
- for (RubyLintVisitor visitor : visitors) {
- visitor.exitDefnNode(iVisited);
- }
- return ins;
- }
-
- @Override
- public Instruction visitDefsNode(DefsNode iVisited) {
- for (RubyLintVisitor visitor : visitors) {
- visitor.visitDefsNode(iVisited);
- }
- Instruction ins = super.visitDefsNode(iVisited);
- for (RubyLintVisitor visitor : visitors) {
- visitor.exitDefsNode(iVisited);
- }
- return ins;
- }
-
-
- @Override
- public Instruction visitDotNode(DotNode iVisited) {
- for (RubyLintVisitor visitor : visitors) {
- visitor.visitDotNode(iVisited);
- }
- return super.visitDotNode(iVisited);
- }
-
- @Override
- public Instruction visitDRegxNode(DRegexpNode iVisited) {
- for (RubyLintVisitor visitor : visitors) {
- visitor.visitDRegxNode(iVisited);
- }
- return super.visitDRegxNode(iVisited);
- }
-
- @Override
- public Instruction visitDStrNode(DStrNode iVisited) {
- for (RubyLintVisitor visitor : visitors) {
- visitor.visitDStrNode(iVisited);
- }
- return super.visitDStrNode(iVisited);
- }
-
- @Override
- public Instruction visitDSymbolNode(DSymbolNode iVisited) {
- for (RubyLintVisitor visitor : visitors) {
- visitor.visitDSymbolNode(iVisited);
- }
- return super.visitDSymbolNode(iVisited);
- }
-
- @Override
- public Instruction visitDVarNode(DVarNode iVisited) {
- for (RubyLintVisitor visitor : visitors) {
- visitor.visitDVarNode(iVisited);
- }
- return super.visitDVarNode(iVisited);
- }
-
- @Override
- public Instruction visitDXStrNode(DXStrNode iVisited) {
- for (RubyLintVisitor visitor : visitors) {
- visitor.visitDXStrNode(iVisited);
- }
- return super.visitDXStrNode(iVisited);
- }
-
- @Override
- public Instruction visitEnsureNode(EnsureNode iVisited) {
- for (RubyLintVisitor visitor : visitors) {
- visitor.visitEnsureNode(iVisited);
- }
- return super.visitEnsureNode(iVisited);
- }
-
- @Override
- public Instruction visitEvStrNode(EvStrNode iVisited) {
- for (RubyLintVisitor visitor : visitors) {
- visitor.visitEvStrNode(iVisited);
- }
- return super.visitEvStrNode(iVisited);
- }
-
- @Override
- public Instruction visitFalseNode(FalseNode iVisited) {
- for (RubyLintVisitor visitor : visitors) {
- visitor.visitFalseNode(iVisited);
- }
- return super.visitFalseNode(iVisited);
- }
-
- @Override
- public Instruction visitFCallNode(FCallNode iVisited) {
- for (RubyLintVisitor visitor : visitors) {
- visitor.visitFCallNode(iVisited);
- }
- return super.visitFCallNode(iVisited);
- }
-
- @Override
- public Instruction visitFixnumNode(FixnumNode iVisited) {
- for (RubyLintVisitor visitor : visitors) {
- visitor.visitFixnumNode(iVisited);
- }
- return super.visitFixnumNode(iVisited);
- }
-
- @Override
- public Instruction visitFlipNode(FlipNode iVisited) {
- for (RubyLintVisitor visitor : visitors) {
- visitor.visitFlipNode(iVisited);
- }
- return super.visitFlipNode(iVisited);
- }
-
- @Override
- public Instruction visitFloatNode(FloatNode iVisited) {
- for (RubyLintVisitor visitor : visitors) {
- visitor.visitFloatNode(iVisited);
- }
- return super.visitFloatNode(iVisited);
- }
-
- @Override
- public Instruction visitForNode(ForNode iVisited) {
- for (RubyLintVisitor visitor : visitors) {
- visitor.visitForNode(iVisited);
- }
- return super.visitForNode(iVisited);
- }
-
- @Override
- public Instruction visitGlobalAsgnNode(GlobalAsgnNode iVisited) {
- for (RubyLintVisitor visitor : visitors) {
- visitor.visitGlobalAsgnNode(iVisited);
- }
- return super.visitGlobalAsgnNode(iVisited);
- }
-
- @Override
- public Instruction visitGlobalVarNode(GlobalVarNode iVisited) {
- for (RubyLintVisitor visitor : visitors) {
- visitor.visitGlobalVarNode(iVisited);
- }
- return super.visitGlobalVarNode(iVisited);
- }
-
- @Override
- public Instruction visitHashNode(HashNode iVisited) {
- for (RubyLintVisitor visitor : visitors) {
- visitor.visitHashNode(iVisited);
- }
- return super.visitHashNode(iVisited);
- }
-
- @Override
- public Instruction visitIfNode(IfNode iVisited) {
- for (RubyLintVisitor visitor : visitors) {
- visitor.visitIfNode(iVisited);
- }
- Instruction ins = super.visitIfNode(iVisited);
- for (RubyLintVisitor visitor : visitors) {
- visitor.exitIfNode(iVisited);
- }
- return ins;
- }
-
- @Override
- public Instruction visitInstAsgnNode(InstAsgnNode iVisited) {
- for (RubyLintVisitor visitor : visitors) {
- visitor.visitInstAsgnNode(iVisited);
- }
- return super.visitInstAsgnNode(iVisited);
- }
-
- @Override
- public Instruction visitInstVarNode(InstVarNode iVisited) {
- for (RubyLintVisitor visitor : visitors) {
- visitor.visitInstVarNode(iVisited);
- }
- return super.visitInstVarNode(iVisited);
- }
-
- @Override
- public Instruction visitIterNode(IterNode iVisited) {
- for (RubyLintVisitor visitor : visitors) {
- visitor.visitIterNode(iVisited);
- }
- return super.visitIterNode(iVisited);
- }
-
- @Override
- public Instruction visitLocalAsgnNode(LocalAsgnNode iVisited) {
- for (RubyLintVisitor visitor : visitors) {
- visitor.visitLocalAsgnNode(iVisited);
- }
- return super.visitLocalAsgnNode(iVisited);
- }
-
- @Override
- public Instruction visitLocalVarNode(LocalVarNode iVisited) {
- for (RubyLintVisitor visitor : visitors) {
- visitor.visitLocalVarNode(iVisited);
- }
- return super.visitLocalVarNode(iVisited);
- }
-
- @Override
- public Instruction visitMatch2Node(Match2Node iVisited) {
- for (RubyLintVisitor visitor : visitors) {
- visitor.visitMatch2Node(iVisited);
- }
- return super.visitMatch2Node(iVisited);
- }
-
- @Override
- public Instruction visitMatch3Node(Match3Node iVisited) {
- for (RubyLintVisitor visitor : visitors) {
- visitor.visitMatch3Node(iVisited);
- }
- return super.visitMatch3Node(iVisited);
- }
-
- @Override
- public Instruction visitMatchNode(MatchNode iVisited) {
- for (RubyLintVisitor visitor : visitors) {
- visitor.visitMatchNode(iVisited);
- }
- return super.visitMatchNode(iVisited);
- }
-
- @Override
- public Instruction visitModuleNode(ModuleNode iVisited) {
- for (RubyLintVisitor visitor : visitors) {
- visitor.visitModuleNode(iVisited);
- }
- Instruction ins = super.visitModuleNode(iVisited);
- for (RubyLintVisitor visitor : visitors) {
- visitor.exitModuleNode(iVisited);
- }
- return ins;
- }
-
- @Override
- public Instruction visitMultipleAsgnNode(MultipleAsgnNode iVisited) {
- for (RubyLintVisitor visitor : visitors) {
- visitor.visitMultipleAsgnNode(iVisited);
- }
- return super.visitMultipleAsgnNode(iVisited);
- }
-
- @Override
- public Instruction visitNewlineNode(NewlineNode iVisited) {
- for (RubyLintVisitor visitor : visitors) {
- visitor.visitNewlineNode(iVisited);
- }
- return super.visitNewlineNode(iVisited);
- }
-
- @Override
- public Instruction visitNextNode(NextNode iVisited) {
- for (RubyLintVisitor visitor : visitors) {
- visitor.visitNextNode(iVisited);
- }
- return super.visitNextNode(iVisited);
- }
-
- @Override
- public Instruction visitNilNode(NilNode iVisited) {
- for (RubyLintVisitor visitor : visitors) {
- visitor.visitNilNode(iVisited);
- }
- return super.visitNilNode(iVisited);
- }
-
- @Override
- public Instruction visitNotNode(NotNode iVisited) {
- for (RubyLintVisitor visitor : visitors) {
- visitor.visitNotNode(iVisited);
- }
- return super.visitNotNode(iVisited);
- }
-
- @Override
- public Instruction visitNthRefNode(NthRefNode iVisited) {
- for (RubyLintVisitor visitor : visitors) {
- visitor.visitNthRefNode(iVisited);
- }
- return super.visitNthRefNode(iVisited);
- }
-
- @Override
- public Instruction visitOpAsgnAndNode(OpAsgnAndNode iVisited) {
- for (RubyLintVisitor visitor : visitors) {
- visitor.visitOpAsgnAndNode(iVisited);
- }
- return super.visitOpAsgnAndNode(iVisited);
- }
-
- @Override
- public Instruction visitOpAsgnNode(OpAsgnNode iVisited) {
- for (RubyLintVisitor visitor : visitors) {
- visitor.visitOpAsgnNode(iVisited);
- }
- return super.visitOpAsgnNode(iVisited);
- }
-
- @Override
- public Instruction visitOpAsgnOrNode(OpAsgnOrNode iVisited) {
- for (RubyLintVisitor visitor : visitors) {
- visitor.visitOpAsgnOrNode(iVisited);
- }
- return super.visitOpAsgnOrNode(iVisited);
- }
-
- @Override
- public Instruction visitOpElementAsgnNode(OpElementAsgnNode iVisited) {
- for (RubyLintVisitor visitor : visitors) {
- visitor.visitOpElementAsgnNode(iVisited);
- }
- return super.visitOpElementAsgnNode(iVisited);
- }
-
- @Override
- public Instruction visitOptNNode(OptNNode iVisited) {
- for (RubyLintVisitor visitor : visitors) {
- visitor.visitOptNNode(iVisited);
- }
- return super.visitOptNNode(iVisited);
- }
-
- @Override
- public Instruction visitOrNode(OrNode iVisited) {
- for (RubyLintVisitor visitor : visitors) {
- visitor.visitOrNode(iVisited);
- }
- return super.visitOrNode(iVisited);
- }
-
- @Override
- public Instruction visitPostExeNode(PostExeNode iVisited) {
- for (RubyLintVisitor visitor : visitors) {
- visitor.visitPostExeNode(iVisited);
- }
- return super.visitPostExeNode(iVisited);
- }
-
- @Override
- public Instruction visitRedoNode(RedoNode iVisited) {
- for (RubyLintVisitor visitor : visitors) {
- visitor.visitRedoNode(iVisited);
- }
- return super.visitRedoNode(iVisited);
- }
-
- @Override
- public Instruction visitRegexpNode(RegexpNode iVisited) {
- for (RubyLintVisitor visitor : visitors) {
- visitor.visitRegexpNode(iVisited);
- }
- return super.visitRegexpNode(iVisited);
- }
-
- @Override
- public Instruction visitRescueBodyNode(RescueBodyNode iVisited) {
- for (RubyLintVisitor visitor : visitors) {
- visitor.visitRescueBodyNode(iVisited);
- }
- return super.visitRescueBodyNode(iVisited);
- }
-
- @Override
- public Instruction visitRescueNode(RescueNode iVisited) {
- for (RubyLintVisitor visitor : visitors) {
- visitor.visitRescueNode(iVisited);
- }
- return super.visitRescueNode(iVisited);
- }
-
- @Override
- public Instruction visitRetryNode(RetryNode iVisited) {
- for (RubyLintVisitor visitor : visitors) {
- visitor.visitRetryNode(iVisited);
- }
- return super.visitRetryNode(iVisited);
- }
-
- @Override
- public Instruction visitReturnNode(ReturnNode iVisited) {
- for (RubyLintVisitor visitor : visitors) {
- visitor.visitReturnNode(iVisited);
- }
- return super.visitReturnNode(iVisited);
- }
-
- @Override
- public Instruction visitRootNode(RootNode iVisited) {
- for (RubyLintVisitor visitor : visitors) {
- visitor.visitRootNode(iVisited);
- }
- return super.visitRootNode(iVisited);
- }
-
- @Override
- public Instruction visitSClassNode(SClassNode iVisited) {
- for (RubyLintVisitor visitor : visitors) {
- visitor.visitSClassNode(iVisited);
- }
- Instruction ins = super.visitSClassNode(iVisited);
- for (RubyLintVisitor visitor : visitors) {
- visitor.exitSClassNode(iVisited);
- }
- return ins;
- }
-
- @Override
- public Instruction visitSelfNode(SelfNode iVisited) {
- for (RubyLintVisitor visitor : visitors) {
- visitor.visitSelfNode(iVisited);
- }
- return super.visitSelfNode(iVisited);
- }
-
- @Override
- public Instruction visitSplatNode(SplatNode iVisited) {
- for (RubyLintVisitor visitor : visitors) {
- visitor.visitSplatNode(iVisited);
- }
- return super.visitSplatNode(iVisited);
- }
-
- @Override
- public Instruction visitStrNode(StrNode iVisited) {
- for (RubyLintVisitor visitor : visitors) {
- visitor.visitStrNode(iVisited);
- }
- return super.visitStrNode(iVisited);
- }
-
- @Override
- public Instruction visitSuperNode(SuperNode iVisited) {
- for (RubyLintVisitor visitor : visitors) {
- visitor.visitSuperNode(iVisited);
- }
- return super.visitSuperNode(iVisited);
- }
-
- @Override
- public Instruction visitSValueNode(SValueNode iVisited) {
- for (RubyLintVisitor visitor : visitors) {
- visitor.visitSValueNode(iVisited);
- }
- return super.visitSValueNode(iVisited);
- }
-
- @Override
- public Instruction visitSymbolNode(SymbolNode iVisited) {
- for (RubyLintVisitor visitor : visitors) {
- visitor.visitSymbolNode(iVisited);
- }
- return super.visitSymbolNode(iVisited);
- }
-
- @Override
- public Instruction visitToAryNode(ToAryNode iVisited) {
- for (RubyLintVisitor visitor : visitors) {
- visitor.visitToAryNode(iVisited);
- }
- return super.visitToAryNode(iVisited);
- }
-
- @Override
- public Instruction visitTrueNode(TrueNode iVisited) {
- for (RubyLintVisitor visitor : visitors) {
- visitor.visitTrueNode(iVisited);
- }
- return super.visitTrueNode(iVisited);
- }
-
- @Override
- public Instruction visitUndefNode(UndefNode iVisited) {
- for (RubyLintVisitor visitor : visitors) {
- visitor.visitUndefNode(iVisited);
- }
- return super.visitUndefNode(iVisited);
- }
-
- @Override
- public Instruction visitUntilNode(UntilNode iVisited) {
- for (RubyLintVisitor visitor : visitors) {
- visitor.visitUntilNode(iVisited);
- }
- return super.visitUntilNode(iVisited);
- }
-
- @Override
- public Instruction visitVAliasNode(VAliasNode iVisited) {
- for (RubyLintVisitor visitor : visitors) {
- visitor.visitVAliasNode(iVisited);
- }
- return super.visitVAliasNode(iVisited);
- }
-
- @Override
- public Instruction visitVCallNode(VCallNode iVisited) {
- for (RubyLintVisitor visitor : visitors) {
- visitor.visitVCallNode(iVisited);
- }
- return super.visitVCallNode(iVisited);
- }
-
- @Override
- public Instruction visitWhenNode(WhenNode iVisited) {
- for (RubyLintVisitor visitor : visitors) {
- visitor.visitWhenNode(iVisited);
- }
- Instruction ins = supe...
[truncated message content] |
