public override int CompareTo(UstNode other)
{
if (other == null)
{
return((int)NodeType);
}
if (other.NodeType == NodeType.PatternTryCatchStatement)
{
return(0);
}
if (other.NodeType != NodeType.TryCatchStatement)
{
return(NodeType - other.NodeType);
}
var otherTryCatch = (TryCatchStatement)other;
if (otherTryCatch.CatchClauses == null)
{
return(-1);
}
else
{
if (otherTryCatch.CatchClauses.Any(catchClause => catchClause.Body.Statements.Count() == 0))
{
return(0);
}
else
{
return(-1);
}
}
}
private static CodeEntityDetails CreateCodeEntity(string name,
string @namespace,
string signature,
PackageVersionPair package,
string originalDefinition,
CodeEntityType codeEntityType,
UstNode ustNode)
{
return(new CodeEntityDetails
{
Name = name,
Namespace = @namespace ?? string.Empty,
Signature = signature,
OriginalDefinition = originalDefinition,
CodeEntityType = codeEntityType,
TextSpan = new TextSpan
{
StartCharPosition = ustNode.TextSpan?.StartCharPosition,
EndCharPosition = ustNode.TextSpan?.EndCharPosition,
StartLinePosition = ustNode.TextSpan?.StartLinePosition,
EndLinePosition = ustNode.TextSpan?.EndLinePosition
},
// If we found an matching sdk assembly, assume the code is using the sdk.
Package = package ?? new PackageVersionPair()
{
PackageId = "", Version = ""
}
});
}
public MatchingResult(Pattern pattern, UstNode node, TextSpan textSpan)
: this(pattern, new List <UstNode> {
node
})
{
TextSpan = textSpan;
}
public UstNode Deserialize(string data, LanguageFlags sourceLanguage)
{
if (string.IsNullOrEmpty(data))
{
throw new ParsingException("Pattern value can not be empty.")
{
IsPattern = true
};
}
Parser.Logger = Logger;
UstConverter.Logger = Logger;
DslParser.PatternContext patternContext = Parser.Parse(data);
UstConverter.SourceLanguage = sourceLanguage;
UstConverter.Data = data;
DslNode dslNode = UstConverter.Convert(patternContext);
UstNode result = dslNode.Collection.First();
ResultPatternVars = dslNode.PatternVarDefs;
var preprocessor = new UstPreprocessor();
preprocessor.Logger = Logger;
result = new PatternNode(result, dslNode.PatternVarDefs);
result = preprocessor.Preprocess(result);
return(result);
}
/// <summary>
/// TODO: possible replace with binary serialization or protobuf.net for performance reason.
/// </summary>
/// <param name="source"></param>
/// <returns></returns>
public static UstNode Clone(this UstNode source)
{
var json = JsonConvert.SerializeObject(source, stringEnumConverter);
var result = JsonConvert.DeserializeObject <UstNode>(json, astJsonConverter);
return(result);
}
private static CodeEntityDetails CreateCodeEntityDetails(
string name,
string @namespace,
string signature,
string originalDefinition,
CodeEntityType codeEntityType,
UstNode ustNode,
Reference reference,
ExternalReferences externalReferences)
{
var package = GetPackageVersionPair(reference, externalReferences, @namespace);
if (package == null)
{
//If any of these values are populated, this is an internal reference. If they are all null, this is a code entity with no references
if (reference?.Assembly != null ||
reference?.Namespace != null ||
reference?.AssemblySymbol != null ||
reference?.Version != null ||
reference?.AssemblyLocation != null ||
!string.IsNullOrEmpty(@namespace))
{
return(null);
}
}
// Otherwise return the code entity
return(CreateCodeEntity(name, @namespace, signature, package, originalDefinition,
codeEntityType, ustNode));
}
public override UstNode VisitConditionalAccessExpression(ConditionalAccessExpressionSyntax node)
{
UstNode ustNode = base.Visit(node.Expression);
Expression expression = ustNode as Expression;
if (expression == null)
{
expression = new MultichildExpression(((ArgsNode)ustNode).Collection, ustNode.TextSpan, FileNode);
}
Expression whenNotNullExpression;
if (node.WhenNotNull is ElementBindingExpressionSyntax)
{
var args = (ArgsNode)VisitElementBindingExpression((ElementBindingExpressionSyntax)node.WhenNotNull);
whenNotNullExpression = new IndexerExpression(expression, args, args.TextSpan, FileNode);
}
else
{
whenNotNullExpression = (Expression)base.Visit(node.WhenNotNull);
}
var nullExpr = new NullLiteral(default(TextSpan), FileNode);
var binayOpLiteral = new BinaryOperatorLiteral(BinaryOperator.Equal, default(TextSpan), FileNode);
var condition = new BinaryOperatorExpression(expression, binayOpLiteral, nullExpr, default(TextSpan), FileNode);
var result = new ConditionalExpression(condition, nullExpr, whenNotNullExpression, node.GetTextSpan(), FileNode);
return(result);
}
public override UstNode Visit(PatternNode patternVars)
{
UstNode data = Visit(patternVars.Node);
List <PatternVarDef> vars = patternVars.Vars.Select(v => (PatternVarDef)Visit(v)).ToList();
vars.Sort();
return(new PatternNode(data, vars));
}
public void ProcessDsl_PatternVarAlreadyDefined_HandleErrors(string data)
{
Assert.Throws(typeof(ConversionException), () =>
{
var processor = new DslProcessor();
UstNode result = processor.Deserialize(data, LanguageExt.AllPatternLanguages);
});
}
public override int CompareTo(UstNode other)
{
Value = null;
if (other == null)
{
return((int)NodeType);
}
if (other.NodeType == NodeType.PatternVarDef)
{
var otherPatternVarDef = (PatternVarDef)other;
/*var idCompareResult = Id.CompareTo(otherPatternVarDef.Id);
* if (idCompareResult != 0)
* {
* return idCompareResult;
* }*/
var childrenCountCompareResult = Values.Count - otherPatternVarDef.Values.Count;
if (childrenCountCompareResult != 0)
{
return(childrenCountCompareResult);
}
for (int i = 0; i < Values.Count; i++)
{
if (Values[i] == null)
{
if (otherPatternVarDef.Values[i] != null)
{
return(-1);
}
}
else
{
var childCompareResult = Values[i].CompareTo(otherPatternVarDef.Values[i]);
if (childCompareResult != 0)
{
return(childCompareResult);
}
}
}
return(0);
}
foreach (var value in Values)
{
if (value == null || value.CompareTo(other) == 0)
{
Value = value;
return(0);
}
}
return(1);
}
public override int CompareTo(UstNode other)
{
if (other == null)
{
return((int)NodeType);
}
int compareResult;
if (other.NodeType == NodeType.PatternExpression)
{
var otherPatternExpression = (PatternExpression)other;
if (Expression == null ^ otherPatternExpression.Expression == null)
{
return(1);
}
if (Expression == null)
{
if (otherPatternExpression.Expression == null)
{
return(Not == otherPatternExpression.Not ? 0 : 1);
}
else
{
return(1);
}
}
compareResult = Expression.CompareTo(otherPatternExpression.Expression);
if (compareResult != 0)
{
return(compareResult);
}
return(Not == otherPatternExpression.Not ? 0 : 1);
}
if (!(other is Expression)) // compare only with expressions.
{
return(-1);
}
if (Expression == null) // Any expression.
{
return(Not ? (int)NodeType : 0);
}
compareResult = Compare(other);
if (Not)
{
compareResult = compareResult != 0 ? 0 : 1;
}
return(compareResult);
}
public override int CompareTo(UstNode other)
{
if (other == null)
{
return((int)NodeType);
}
int compareResult;
if (other.NodeType == NodeType.PatternStatement)
{
var otherPatternStatement = (PatternStatement)other;
if (Statement == null ^ otherPatternStatement.Statement == null)
{
return(1);
}
if (Statement == null)
{
if (otherPatternStatement.Statement == null)
{
return(Not == otherPatternStatement.Not ? 0 : 1);
}
else
{
return(1);
}
}
compareResult = Statement.CompareTo(otherPatternStatement.Statement);
if (compareResult != 0)
{
return(compareResult);
}
return(Not == otherPatternStatement.Not ? 0 : 1);
}
if (!(other is Statement)) // Compare only with statements.
{
return(-1);
}
if (Statement == null) // Any statement.
{
return(0);
}
compareResult = Compare(other);
if (Not)
{
compareResult = compareResult > 0 ? 0 : compareResult;
}
return(compareResult);
}
public void JsonSerialize_PatternWithVar_JsonEqualsToDsl()
{
var pwdVar = new PatternVarDef {
Id = "pwd", Values = new List <Expression>()
{
new PatternIdToken("password")
}
};
var patternNode = new PatternNode
{
Vars = new List <PatternVarDef>()
{
pwdVar
},
Node = new PatternStatements(
new ExpressionStatement
{
Expression = new AssignmentExpression
{
Left = new PatternVarRef(pwdVar),
Right = new PatternExpression()
}
},
new PatternMultipleStatements(),
new ExpressionStatement
{
Expression = new InvocationExpression
{
Target = new PatternExpression(),
Arguments = new PatternExpressions(
new PatternMultipleExpressions(),
new PatternVarRef(pwdVar),
new PatternMultipleExpressions())
}
}
)
};
var jsonSerializer = new JsonUstNodeSerializer(typeof(UstNode), typeof(PatternVarDef));
jsonSerializer.Indented = true;
jsonSerializer.IncludeTextSpans = false;
string json = jsonSerializer.Serialize(patternNode);
UstNode nodeFromJson = jsonSerializer.Deserialize(json, LanguageExt.AllPatternLanguages);
var dslSeializer = new DslProcessor()
{
PatternExpressionInsideStatement = false
};
var nodeFromDsl = dslSeializer.Deserialize("<[@pwd:password]> = #; ... #(#*, <[@pwd]>, #*);", LanguageExt.AllPatternLanguages);
Assert.IsTrue(nodeFromJson.Equals(patternNode));
Assert.IsTrue(nodeFromJson.Equals(nodeFromDsl));
}
public void Preprocess_MultiMultiPattern_RemovedDuplicates()
{
UstNode patternWithDuplicateMultiStatementsExpressions = new PatternStatements
{
Statements = new List <Statement>()
{
new ExpressionStatement(
new InvocationExpression
{
Target = new IdToken("test_call"),
Arguments = new PatternExpressions
{
Collection = new List <Expression>
{
new IdToken("a"),
new IdToken("b"),
new PatternMultipleExpressions(),
new PatternMultipleExpressions(),
new IdToken("z")
}
}
}),
new PatternMultipleStatements(),
new PatternMultipleStatements(),
new ExpressionStatement(
new VariableDeclarationExpression
{
Type = new TypeToken("int"),
Variables = new List <AssignmentExpression>()
{
new AssignmentExpression
{
Left = new IdToken("a"),
Right = new IntLiteral {
Value = 42
}
}
}
}
)
}
};
var logger = new LoggerMessageCounter();
var processor = new DslProcessor();
UstPreprocessor preprocessor = new UstPreprocessor()
{
Logger = logger
};
UstNode result = preprocessor.Preprocess(patternWithDuplicateMultiStatementsExpressions);
Assert.AreEqual(1, result.GetAllDescendants().Count(child => child.NodeType == NodeType.PatternMultipleStatements));
Assert.AreEqual(1, result.GetAllDescendants().Count(child => child.NodeType == NodeType.PatternMultipleExpressions));
}
public override int CompareTo(UstNode other)
{
var baseCompareResult = base.CompareTo(other);
if (baseCompareResult != 0)
{
return(baseCompareResult);
}
return(String.Compare(Text, ((StringLiteral)other).Text, StringComparison.Ordinal)); // TODO: Regular expressions ???
}
public override int CompareTo(UstNode other)
{
var baseCompareResult = base.CompareTo(other);
if (baseCompareResult != 0)
{
return(baseCompareResult);
}
return(String.Compare(Id, ((IdToken)other).Id, StringComparison.Ordinal));
}
public override int CompareTo(UstNode other)
{
var baseCompareResult = base.CompareTo(other);
if (baseCompareResult != 0)
{
return(baseCompareResult);
}
return(Value.CompareTo(((FloatLiteral)other).Value));
}
protected override UstNode VisitChildren(UstNode ustNode)
{
try
{
return(base.VisitChildren(ustNode));
}
catch
{
return(null);
}
}
private void CheckPattern()
{
if (oldPattern != patternTextBox.Text || oldLanguages != Languages)
{
oldPattern = patternTextBox.Text;
oldLanguages = Languages;
Dispatcher.UIThread.InvokeAsync(PatternErrors.Clear);
patternLogger.Clear();
UstNode patternNode = null;
try
{
if (!string.IsNullOrEmpty(patternTextBox.Text))
{
patternNode = dslProcessor.Deserialize(patternTextBox.Text, Languages);
}
}
catch
{
}
if (patternLogger.ErrorCount == 0)
{
PatternErrorsIsVisible = false;
PatternErrorsText = "";
if (IsDeveloperMode && patternNode != null)
{
PatternJson = ustNodeJsonSerializer.Serialize(patternNode);
File.WriteAllText(Path.Combine(ServiceLocator.TempDirectory, "Pattern UST.json"), PatternJson);
}
}
else
{
PatternErrorsIsVisible = true;
PatternErrorsText = $"ERRORS ({patternLogger.ErrorCount})";
if (IsDeveloperMode)
{
PatternJson = "";
}
}
Dispatcher.UIThread.InvokeAsync(() =>
{
this.RaisePropertyChanged(nameof(PatternErrorsIsVisible));
this.RaisePropertyChanged(nameof(PatternErrorsText));
this.RaisePropertyChanged(nameof(PatternJson));
});
if (ServiceLocator.MainWindowViewModel != null)
{
ServiceLocator.MainWindowViewModel.UpdateMatchings();
}
}
}
public void ProcessDsl_SampleWithSyntaxError_HandleErrors()
{
var logger = new LoggerMessageCounter();
var data = "(?i)password(?-i)]> = <[\"\\w*\" || null]>";
var processor = new DslProcessor()
{
Logger = logger
};
UstNode result = processor.Deserialize(data, LanguageExt.AllPatternLanguages);
Assert.AreEqual(5, logger.ErrorCount);
}
public void Parse_Dsl_WithoutErrors(string fileName)
{
var data = File.ReadAllText(Path.Combine(TestHelper.TestsDataPath, fileName));
var logger = new LoggerMessageCounter();
var processor = new DslProcessor()
{
Logger = logger
};
UstNode result = processor.Deserialize(data, LanguageExt.AllPatternLanguages);
Assert.AreEqual(0, logger.ErrorCount);
}
public override UstNode[] GetChildren()
{
var result = new UstNode[Members.Count + 1];
int index = 0;
result[index++] = Name;
foreach (var member in Members)
{
result[index++] = member;
}
return(result);
}
public override int CompareTo(UstNode other)
{
var baseCompareResult = base.CompareTo(other);
if (baseCompareResult != 0)
{
return(baseCompareResult);
}
var unaryOperatorResult = UnaryOperator - ((UnaryOperatorLiteral)other).UnaryOperator;
return(unaryOperatorResult);
}
public override int CompareTo(UstNode other)
{
var baseCompareResult = base.CompareTo(other);
if (baseCompareResult != 0)
{
return(baseCompareResult);
}
TypeToken otherTypeToken = (TypeToken)other;
return(String.Compare(TextValue, otherTypeToken.TextValue, StringComparison.Ordinal));
}
public override int CompareTo(UstNode other)
{
var baseCompareResult = base.CompareTo(other);
if (baseCompareResult != 0)
{
return(baseCompareResult);
}
var classTypeCompareResult = TypeType - ((TypeTypeLiteral)other).TypeType;
return(classTypeCompareResult);
}
public override int CompareTo(UstNode other)
{
var baseCompareResult = base.CompareTo(other);
if (baseCompareResult != 0)
{
return(baseCompareResult);
}
var modifierCompareResult = Modifier - ((ModifierLiteral)other).Modifier;
return(modifierCompareResult);
}
public static UstNode GetObject(string type)
{
UstNode ustNode = null;
switch (type)
{
case IdConstants.RootIdName:
ustNode = new RootUstNode();
break;
case IdConstants.UsingDirectiveIdName:
ustNode = new UsingDirective();
break;
case IdConstants.NamespaceIdName:
ustNode = new NamespaceDeclaration();
break;
case IdConstants.ClassIdName:
ustNode = new ClassDeclaration();
break;
case IdConstants.InterfaceIdName:
ustNode = new InterfaceDeclaration();
break;
case IdConstants.BodyIdName:
ustNode = new BlockStatement();
break;
case IdConstants.ObjectCreationIdName:
ustNode = new ObjectCreationExpression();
break;
case IdConstants.InvocationIdName:
ustNode = new InvocationExpression();
break;
case IdConstants.LiteralIdName:
ustNode = new LiteralExpression();
break;
case IdConstants.MethodIdName:
ustNode = new MethodDeclaration();
break;
default: break;
}
return(ustNode);
}
protected override UstNode VisitChildren(UstNode ustNode)
{
try
{
return(base.VisitChildren(ustNode));
}
catch (Exception ex)
{
Logger.LogError(new ConversionException(ustNode.FileNode?.FileName?.Text ?? "", ex)
{
TextSpan = ustNode.TextSpan
});
return(null);
}
}
public override int CompareTo(UstNode other)
{
if (other == null)
{
return((int)other.NodeType);
}
if (other is Statement)
{
return(0);
}
else
{
return(NodeType - other.NodeType);
}
}
public void Parse_NewLine_CorrectLineColumn()
{
string fileText = File.ReadAllText(Path.Combine(TestHelper.TestsDataPath, "newLine -r-n.php"));
var lineEnds = new string[] { "\r", "\n", "\r\n" };
foreach (var lineEnd in lineEnds)
{
var phpParser = new PhpAntlrParser();
string code = fileText.Replace("\r\n", lineEnd);
var sourceCodeFile = new SourceCodeFile
{
Name = "newLine.php",
Code = code
};
var parseTree = (PhpAntlrParseTree)phpParser.Parse(sourceCodeFile);
var converter = new PhpAntlrParseTreeConverter();
Ust ust = converter.Convert(parseTree);
UstNode intNode = ust.Root.GetAllDescendants(
node => node.NodeType == NodeType.IntLiteral &&
((IntLiteral)node).Value == 42).First();
int beginLine, beginColumn, endLine, endColumn;
TextHelper.ToLineColumn(intNode.TextSpan, code, out beginLine, out beginColumn, out endLine, out endColumn);
Assert.AreEqual(1, beginLine);
Assert.AreEqual(12, beginColumn);
Assert.AreEqual(14, endColumn);
UstNode heredocNode = ust.Root.GetAllDescendants(
node => node.NodeType == NodeType.StringLiteral &&
((StringLiteral)node).Text.StartsWith("Heredoc text")).First();
TextHelper.ToLineColumn(heredocNode.TextSpan, code, out beginLine, out beginColumn, out endLine, out endColumn);
Assert.AreEqual(3, beginLine);
Assert.AreEqual(6, endLine);
UstNode serverAddressNode = ust.Root.GetAllDescendants(
node => node.NodeType == NodeType.StringLiteral &&
((StringLiteral)node).Text.Contains("http://127.0.0.1")).First();
TextHelper.ToLineColumn(serverAddressNode.TextSpan, code, out beginLine, out beginColumn, out endLine, out endColumn);
Assert.AreEqual(8, beginLine);
Assert.AreEqual(15, beginColumn);
}
}
