public override bool Visit(IParseTree tree)
{
if (tree as TerminalNodeImpl != null)
{
Results[tree] = true;
tree.Accept(this);
return(true);
}
return(tree.Accept(this));
}
public void CollectionTest1()
{
var stream = CharStreams.fromstring(@"package RobotsTestModel
context aMotorsForward
inv@0:
Bag{ ""a"", ""bb"", ""ccc""}->select(self->size() = 2)->size() = 1
inv@0:
Bag{1,2,3}->forAll(x, y | x <> y implies x*y > 1)
inv@0:
Bag{1,2,3}->iterate(x; y : T = 0 | y + x) = 6
inv@0:
Set{""1"",""2"",""3""}->collect(self = ""0"")->size() = 3
inv@0:
Bag{""1"",""2"",""3""}->any(self.toInteger() > 2).toInteger() = 3
inv@0:
aMotorsForward->allInstances()->size() > -1
endpackage");
ITokenSource lexer = new OclLexer(stream);
ITokenStream tokens = new CommonTokenStream(lexer);
var parser = new OclParser(tokens)
{
BuildParseTree = true
};
IParseTree tree = parser.oclFile();
Assert.IsTrue(tree.Accept(interpreter));
}
static void Main(string[] args)
{
String input = @"package P
context A
inv:
let fact(n: var) = if n = 1 then n else n * fact(n - 1) endif;
let n = 5;
fact(n+1) = 720
inv:
let a = 6;
let b = 6;
a = b
endpackage";
ICharStream stream = CharStreams.fromstring(input);
ITokenSource lexer = new HelloLexer(stream);
ITokenStream tokens = new CommonTokenStream(lexer);
HelloParser parser = new HelloParser(tokens);
parser.BuildParseTree = true;
IParseTree tree = parser.oclFile();
HelloPrinter printer = new HelloPrinter();
//ParseTreeWalker.Default.Walk(printer, tree);
tree.Accept(printer);
Console.ReadLine();
}
public void StringTest1()
{
var stream = CharStreams.fromstring(@"package RobotsTestModel
context aMotorsForward
inv@0:
""ABC""->toLower() = ""abc""
inv@0:
""123""->toInteger() = 123
inv@0:
""123""->toReal() = 123
inv@0:
""abc""->toUpper() = ""ABC""
inv@0:
""abc""->concat(""cde"")->toUpper() = ""ABCCDE""
inv@0:
""abc""->substring(1, 1) = ""a""
endpackage");
ITokenSource lexer = new OclLexer(stream);
ITokenStream tokens = new CommonTokenStream(lexer);
var parser = new OclParser(tokens)
{
BuildParseTree = true
};
IParseTree tree = parser.oclFile();
Assert.IsTrue(tree.Accept(interpreter));
}
public override Expression Visit(IParseTree node)
{
// Hack. There is no language construct that says "all Visit*()"
// methods must be implemented all tree node types used.
// So, get the node type, and use reflection on this class to find
// a visit method overriden for the node type. If not, throw
// "not implemented".
if (node as TerminalNodeImpl == null)
{
Type type = node.GetType();
Type this_type = this.GetType();
string type_name = type.Name;
// node type: Parenthesized_expressionContext
// method name: VisitParenthesized_expression
Regex regex = new Regex("Context$");
string name = regex.Replace(type_name, "");
string method_name = "Visit" + name;
IEnumerable <MethodInfo> m = this_type.GetTypeInfo().GetDeclaredMethods(method_name);
if (!m.GetEnumerator().MoveNext())
{
ParserRuleContext where = node as ParserRuleContext;
IToken token = where.Start;
int index = token.StartIndex;
// No method by the given name exists, which means it's unimplemented.
throw new Helpers.EvaluationException("unimplemented feature (" + name + ")", index);
}
}
return(node.Accept(this));
}
public void NumberTest1()
{
var stream = CharStreams.fromstring(@"package RobotsTestModel
context aMotorsForward
inv@0:
1->max(2) = 2
inv@0:
5->div(2) = 2
inv@0:
5->min(2) = 2
inv@0:
5->mod(2) = 1
inv@0:
5->abs() = 5
endpackage");
ITokenSource lexer = new OclLexer(stream);
ITokenStream tokens = new CommonTokenStream(lexer);
var parser = new OclParser(tokens)
{
BuildParseTree = true
};
IParseTree tree = parser.oclFile();
Assert.IsTrue(tree.Accept(interpreter));
}
public string Visit(IParseTree tree)
{
try
{
return(tree.Accept(this));
}
catch
{
if (tree is ParserRuleContext)
{
//AntlrHelper.LogConversionError(ex, parserRuleContext, FileNode.FileName.Text, FileNode.FileData, Logger);
}
return(DefaultResult);
}
}
/// <summary>
/// <inheritDoc></inheritDoc>
/// <p/>
/// The default implementation initializes the aggregate result to
/// <see cref="AbstractParseTreeVisitor{Result}.DefaultResult()">defaultResult()</see>
/// . Before visiting each child, it
/// calls
/// <see cref="AbstractParseTreeVisitor{Result}.ShouldVisitNextChild(IRuleNode, Result)">shouldVisitNextChild</see>
/// ; if the result
/// is
/// <code>false</code>
/// no more children are visited and the current aggregate
/// result is returned. After visiting a child, the aggregate result is
/// updated by calling
/// <see cref="AbstractParseTreeVisitor{Result}.AggregateResult(Result, Result)">aggregateResult
/// </see>
/// with the
/// previous aggregate result and the result of visiting the child.
/// </summary>
public virtual Result VisitChildren(IRuleNode node)
{
Result result = DefaultResult();
int n = node.ChildCount;
for (int i = 0; i < n; i++)
{
if (!ShouldVisitNextChild(node, result))
{
break;
}
IParseTree c = node.GetChild(i);
Result childResult = c.Accept(this);
result = AggregateResult(result, childResult);
}
return(result);
}
public void FuncTest1()
{
var stream = CharStreams.fromstring(@"package ObjectMetamodel
context FunctionNode
inv@2:
self.params@1 <> self.callParams@2
endpackage");
ITokenSource lexer = new OclLexer(stream);
ITokenStream tokens = new CommonTokenStream(lexer);
var parser = new OclParser(tokens)
{
BuildParseTree = true
};
IParseTree tree = parser.oclFile();
Assert.IsTrue(tree.Accept(interpreter));
}
// public override bool Visit(IParseTree tree)
// {
// throw new NotImplementedException();
// }
//public override bool VisitTerminal(ITerminalNode node)
//{
// Errors.Add("ERROR: Line 3, Column 4: wtf??");
// return true;
//}
public override bool VisitChildren(IRuleNode node)
{
bool result = DefaultResult;
int n = node.ChildCount;
for (int i = 0; i < n; i++)
{
if (!ShouldVisitNextChild(node, result))
{
break;
}
IParseTree c = node.GetChild(i);
bool childResult = c.Accept(this);
//result = AggregateResult(result, childResult);
result = result || childResult;
}
return(result);
}
public Ust Visit(IParseTree tree)
{
try
{
if (tree == null)
{
return(null);
}
return(tree.Accept(this));
}
catch (Exception ex) when(!(ex is ThreadAbortException))
{
if (tree is ParserRuleContext parserRuleContext)
{
Logger.LogConversionError(ex, parserRuleContext, root.SourceCodeFile);
}
return(DefaultResult);
}
}
public override Node VisitChildren(IRuleNode node)
{
NodeList result = new NodeList();
int n = node.ChildCount;
for (int i = 0; i < n; i++)
{
if (!ShouldVisitNextChild(node, result))
{
break;
}
IParseTree c = node.GetChild(i);
Node childResult = c.Accept(this);
if (childResult == null)
{
continue;
}
result.Childs.Add(childResult);
}
return(result);
}
public override object VisitChildren([NotNull] IRuleNode node)
{
object result = null;
int n = node.ChildCount;
for (int i = 0; i < n; i++)
{
if (!ShouldVisitNextChild(node, result))
{
break;
}
IParseTree c = node.GetChild(i);
if (c is TerminalNodeImpl || c is ErrorNodeImpl)
{
continue;
}
object childResult = c.Accept(this);
result = AggregateResult(result, childResult);
}
return(result);
}
public UstNode Visit(IParseTree tree)
{
try
{
if (tree == null)
{
return(null);
}
return(tree.Accept(this));
}
catch (Exception ex)
{
var parserRuleContext = tree as ParserRuleContext;
if (parserRuleContext != null)
{
AntlrHelper.LogConversionError(ex, parserRuleContext, FileNode.FileName.Text, FileNode.FileData, Logger);
}
return(DefaultResult);
}
}
public override ParseTreeNode VisitChildren(IRuleNode node)
{
ParseTreeNode result = new ParseTreeNode();
/*if(node.RuleContext is Java8Parser.CompilationUnitContext
||node.RuleContext is Java8Parser.NormalClassDeclarationContext
||node.RuleContext is Java8Parser.FieldDeclarationContext
||node.RuleContext is Java8Parser.MethodDeclarationContext
||node.RuleContext is Java8Parser.InterfaceDeclarationContext
||node.RuleContext is Java8Parser.InterfaceMethodDeclarationContext)
* {
* result = DefaultResult;
* }*/
int n = node.ChildCount;
for (int i = 0; i < n; i++)
{
if (!ShouldVisitNextChild(node, result))
{
break;
}
IParseTree c = node.GetChild(i);
ParseTreeNode childResult = c.Accept(this);
//result = AggregateResult(result, childResult);
if (childResult != null)
{
if (childResult.ItemType == IClassParser.ItemType.__InternalPlaceHolder ||
childResult.ItemType == IClassParser.ItemType.Field) //expand sub items
{
result.Children = result.Children.Concat(childResult.Children).ToList();
}
else
{
result.Children.Add(childResult);
}
}
}
return(result);
}
public ExpressionNode Parse(string expression)
{
var stream = CharStreams.fromString(expression);
var lexer = new AudioSynthesisGrammarLexer(stream);
var tokens = new CommonTokenStream(lexer);
var parser = new AudioSynthesisGrammarParser(tokens);
parser.BuildParseTree = true;
parser.RemoveErrorListeners();
parser.AddErrorListener(new ThrowingErrorListener <IToken>());
IParseTree tree = parser.compileUnit();
var visitor = new AudioSynthesisVisitor();
var res = tree.Accept(visitor);
if (res is null)
{
throw new ParseError("Unexpected null building AST.");
}
return(res);
}
/// <summary>
/// this is the default implementation of antlr
/// AbstractParseTreeVisitor.VisitChildren
/// the differences are the comments
/// </summary>
/// <param name="node"></param>
/// <returns></returns>
public override Node VisitChildren(IRuleNode node)
{
NodeList result = new NodeList();
//Result result = DefaultResult;
int n = node.ChildCount;
for (int i = 0; i < n; i++)
{
if (!ShouldVisitNextChild(node, result))
{
break;
}
IParseTree c = node.GetChild(i);
Node childResult = c.Accept(this);
//result = AggregateResult(result, childResult);/// maybe we should override this method instead
if (childResult == null)
{
continue;
}
result.Childs.Add(childResult);
}
return(result);
}
public VbaParseTree Visit(IParseTree tree)
{
return(tree.Accept(this));
}
/// <summary>
/// <inheritDoc></inheritDoc>
/// <p/>
/// The default implementation calls
/// <see cref="IParseTree.Accept{T}(IParseTreeVisitor{T})">IParseTree.Accept<T>(IParseTreeVisitor<Result>)
/// </see>
/// on the
/// specified tree.
/// </summary>
public virtual Result Visit(IParseTree tree)
{
return(tree.Accept(this));
}
//Scope<TypeSymbol> varTypes;
//Scope<TypeSymbol> functionTypes;
public override ASTNode Visit(IParseTree tree)
{
//varTypes = new Scope<TypeSymbol>();
//functionTypes = new Scope<TypeSymbol>();
return(tree.Accept(this));
}
internal CodeAnalyzerResult AnalyzeModule(string moduleName, string moduleCode)
{
RubberduckParseResult rubberduckParseResult = Parse(moduleName, moduleCode);
RubberduckParserState parserState = rubberduckParseResult.ParserState;
if (parserState.Status != ParserState.Ready)
{
return(new CodeAnalyzerResult(moduleName)
{
VbaCodeIssues = GetModuleExceptions(moduleName, parserState)
});
}
List <VbaCodeIssue> vbaCodeIssues = new[]
{
Inspect <ApplicationWorksheetFunctionInspection>(moduleName, parserState, ResultFetchMethod.NoHelper),
Inspect <AssignedByValParameterInspection>(moduleName, parserState, ResultFetchMethod.NoHelper),
Inspect <ConstantNotUsedInspection>(moduleName, parserState, ResultFetchMethod.NoHelper),
//Inspect<EmptyIfBlockInspection>(moduleName, parserState, ResultFetchMethod.UsingHelper),
Inspect <EmptyStringLiteralInspection>(moduleName, parserState, ResultFetchMethod.NoHelper),
Inspect <EncapsulatePublicFieldInspection>(moduleName, parserState, ResultFetchMethod.NoHelper),
Inspect <FunctionReturnValueNotUsedInspection>(moduleName, parserState, ResultFetchMethod.NoHelper),
Inspect <ImplicitActiveSheetReferenceInspection>(moduleName, parserState, ResultFetchMethod.NoHelper),
Inspect <ImplicitActiveWorkbookReferenceInspection>(moduleName, parserState, ResultFetchMethod.NoHelper),
Inspect <ImplicitByRefModifierInspection>(moduleName, parserState, ResultFetchMethod.NoHelper),
Inspect <ImplicitPublicMemberInspection>(moduleName, parserState, ResultFetchMethod.NoHelper),
Inspect <ImplicitVariantReturnTypeInspection>(moduleName, parserState, ResultFetchMethod.NoHelper),
Inspect <MemberNotOnInterfaceInspection>(moduleName, parserState, ResultFetchMethod.NoHelper),
Inspect <MissingAnnotationArgumentInspection>(moduleName, parserState, ResultFetchMethod.NoHelper),
Inspect <ModuleScopeDimKeywordInspection>(moduleName, parserState, ResultFetchMethod.NoHelper),
Inspect <MoveFieldCloserToUsageInspection>(moduleName, parserState, ResultFetchMethod.NoHelper),
Inspect <MultilineParameterInspection>(moduleName, parserState, ResultFetchMethod.UsingHelper),
Inspect <MultipleDeclarationsInspection>(moduleName, parserState, ResultFetchMethod.UsingHelper),
Inspect <NonReturningFunctionInspection>(moduleName, parserState, ResultFetchMethod.NoHelper),
Inspect <ObsoleteCallStatementInspection>(moduleName, parserState, ResultFetchMethod.UsingHelper),
Inspect <ObsoleteCommentSyntaxInspection>(moduleName, parserState, ResultFetchMethod.UsingHelper),
Inspect <ObsoleteGlobalInspection>(moduleName, parserState, ResultFetchMethod.NoHelper),
Inspect <ObsoleteLetStatementInspection>(moduleName, parserState, ResultFetchMethod.UsingHelper),
Inspect <ObsoleteTypeHintInspection>(moduleName, parserState, ResultFetchMethod.NoHelper),
Inspect <OptionBaseInspection>(moduleName, parserState, ResultFetchMethod.UsingHelper),
Inspect <OptionBaseInspection>(moduleName, parserState, ResultFetchMethod.UsingHelper),
Inspect <OptionExplicitInspection>(moduleName, parserState, ResultFetchMethod.UsingHelper),
Inspect <ParameterCanBeByValInspection>(moduleName, parserState, ResultFetchMethod.NoHelper),
Inspect <ParameterNotUsedInspection>(moduleName, parserState, ResultFetchMethod.NoHelper),
Inspect <ProcedureCanBeWrittenAsFunctionInspection>(moduleName, parserState, ResultFetchMethod.UsingHelper),
Inspect <ProcedureNotUsedInspection>(moduleName, parserState, ResultFetchMethod.NoHelper),
Inspect <SelfAssignedDeclarationInspection>(moduleName, parserState, ResultFetchMethod.NoHelper),
Inspect <UnassignedVariableUsageInspection>(moduleName, parserState, ResultFetchMethod.NoHelper),
Inspect <UndeclaredVariableInspection>(moduleName, parserState, ResultFetchMethod.NoHelper),
Inspect <UntypedFunctionUsageInspection>(moduleName, parserState, ResultFetchMethod.NoHelper),
Inspect <VariableNotAssignedInspection>(moduleName, parserState, ResultFetchMethod.NoHelper),
Inspect <VariableNotUsedInspection>(moduleName, parserState, ResultFetchMethod.NoHelper),
Inspect <VariableTypeNotDeclaredInspection>(moduleName, parserState, ResultFetchMethod.NoHelper),
Inspect <WriteOnlyPropertyInspection>(moduleName, parserState, ResultFetchMethod.NoHelper)
}.SelectMany(x => x).ToList();
IParseTree parseTree = rubberduckParseResult.GetParseTree(moduleName);
return(new CodeAnalyzerResult(moduleName)
{
VbaCodeIssues = vbaCodeIssues, ParseTree = parseTree.Accept(new SerializableObjectStructureVisitor())
});
}
public Expression Visit(IParseTree tree) => tree.Accept(this);
