IExpression Write(ImmutableList <string> symbols)
{
IExpression WriteExpression(ImmutableList <string> symbols)
{
var value = Expression(symbols);
return(new Write(value));
}
Expect(TokenTag.LParen);
if (Match(TokenTag.RParen))
{
throw new SyntaxErrorException(
$"write requires at least one argument",
Current.Position);
}
var left = WriteExpression(symbols);
while (Match(TokenTag.Comma))
{
var right = WriteExpression(symbols);
left = new ExpressionPair(left, right);
}
Expect(TokenTag.RParen);
return(left);
}
public override void Switch(IAstTransformer transformer, out Node resultingNode)
{
ExpressionPair thisNode = (ExpressionPair)this;
ExpressionPair resultingTypedNode = thisNode;
transformer.OnExpressionPair(thisNode, ref resultingTypedNode);
resultingNode = resultingTypedNode;
}
bool SetFieldOrProperty(AstAttribute aa, ExpressionPair p)
{
ReferenceExpression name = p.First as ReferenceExpression;
if (null == name)
{
_context.Errors.NamedParameterMustBeReference(p);
return(false);
}
else
{
Reflection.MemberInfo[] members = _type.FindMembers(
Reflection.MemberTypes.Property | Reflection.MemberTypes.Field,
Reflection.BindingFlags.Instance | Reflection.BindingFlags.Public,
Type.FilterName, name.Name);
if (members.Length > 0)
{
if (members.Length > 1)
{
// Essa preocupao parece meio idiota, mas
// como ainda no tenho certeza de que o modelo
// IL no permita dois membros diferentes com mesmo
// nome vou deixar aqui
_context.Errors.AmbiguousName(p, name.Name, members);
return(false);
}
else
{
Reflection.MemberInfo m = members[0];
Reflection.PropertyInfo property = m as Reflection.PropertyInfo;
if (null != property)
{
property.SetValue(aa, p.Second, null);
}
else
{
Reflection.FieldInfo field = m as Reflection.FieldInfo;
if (null != field)
{
field.SetValue(aa, p.Second);
}
else
{
// No poderia chegar aqui jamais!!!
throw new InvalidOperationException();
}
}
}
}
else
{
_context.Errors.NotAPublicFieldOrProperty(name, _type.FullName, name.Name);
return(false);
}
}
return(true);
}
IExpression ExpressionSequence(ImmutableList <string> symbols)
{
var left = Expression(symbols);
while (Match(TokenTag.Semicolon))
{
var right = Expression(symbols);
left = new ExpressionPair(left, right);
}
return(left);
}
bool SetFieldOrProperty(IAstAttribute aa, ExpressionPair p)
{
ReferenceExpression name = p.First as ReferenceExpression;
if (null == name)
{
_context.Errors.Add(CompilerErrorFactory.NamedParameterMustBeIdentifier(p));
return(false);
}
else
{
Reflection.MemberInfo[] members = _type.FindMembers(
Reflection.MemberTypes.Property | Reflection.MemberTypes.Field,
Reflection.BindingFlags.Instance | Reflection.BindingFlags.Public,
Type.FilterName, name.Name);
if (members.Length > 0)
{
if (members.Length > 1)
{
_context.Errors.Add(CompilerErrorFactory.AmbiguousReference(name, members));
return(false);
}
else
{
Reflection.MemberInfo m = members[0];
Reflection.PropertyInfo property = m as Reflection.PropertyInfo;
if (null != property)
{
property.SetValue(aa, p.Second, null);
}
else
{
Reflection.FieldInfo field = m as Reflection.FieldInfo;
if (null != field)
{
field.SetValue(aa, p.Second);
}
else
{
throw new InvalidOperationException();
}
}
}
}
else
{
_context.Errors.Add(CompilerErrorFactory.NotAPublicFieldOrProperty(name, name.Name, _type.FullName));
return(false);
}
}
return(true);
}
override public void LeaveExpressionPair(ExpressionPair pair)
{
Expression converted = ConvertExpression(pair.First);
if (null != converted)
{
pair.First = converted;
}
converted = ConvertExpression(pair.Second);
if (null != converted)
{
pair.Second = converted;
}
}
public override void OnReferenceExpression(ReferenceExpression node)
{
IEntity entity = NameResolutionService.Resolve(node.Name);
//search for the left side of a key in a hash literal expression
if (node.ParentNode is ExpressionPair &&
((ExpressionPair)node.ParentNode).First == node &&
node.ParentNode.ParentNode is HashLiteralExpression)
{
ExpressionPair parent = (ExpressionPair)node.ParentNode;
StringLiteralExpression literal = CodeBuilder.CreateStringLiteral(node.Name);
parent.First = literal;
parent.Replace(node, literal);
return;
}
base.OnReferenceExpression(node);
}
public static void AnalyzeLogicalOrExpression(SyntaxNodeAnalysisContext context)
{
SyntaxNode node = context.Node;
if (node.ContainsDiagnostics)
{
return;
}
if (node.SpanContainsDirectives())
{
return;
}
var logicalOr = (BinaryExpressionSyntax)context.Node;
ExpressionSyntax left = logicalOr.Left.WalkDownParentheses();
ExpressionSyntax right = logicalOr.Right.WalkDownParentheses();
if (left.IsKind(SyntaxKind.LogicalAndExpression) &&
right.IsKind(SyntaxKind.LogicalAndExpression))
{
ExpressionPair expressions = GetExpressionPair((BinaryExpressionSyntax)left);
if (expressions.IsValid)
{
ExpressionPair expressions2 = GetExpressionPair((BinaryExpressionSyntax)right);
if (expressions2.IsValid &&
(expressions.Expression.Kind() == expressions2.NegatedExpression.Kind() &&
expressions.NegatedExpression.Kind() == expressions2.Expression.Kind() &&
expressions.Expression.IsEquivalentTo(expressions2.NegatedExpression, topLevel: false) &&
expressions.NegatedExpression.IsEquivalentTo(expressions2.Expression, topLevel: false)))
{
context.ReportDiagnostic(DiagnosticDescriptors.UseExclusiveOrOperator, logicalOr);
}
}
}
}
public static List<MappingBuilderNode> BuildExpressionTree(ExpressionPair[] mappings)
{
var expressionParts = mappings.Select(m => new ExpressionPart
{
Source = m.Source,
SourcePath = m.Source.ToPathWithEmptyIndexer(),
Parts = ExpressionParser.SplitExpression(m.Dest).ToArray(),
Converter = m.Converter
})
.ToArray();
var nodeMap = new Dictionary<string, MappingBuilderNode>();
foreach (var part in expressionParts)
CreateNodes(part.Parts, part.Source, part.Converter, 0, nodeMap);
var result = nodeMap.Values.OfType<RootNode>()
.Cast<MappingBuilderNode>()
.ToList();
return result;
}
bool SetFieldOrProperty(IAstAttribute aa, ExpressionPair p)
{
var name = p.First as ReferenceExpression;
if (name == null)
{
_context.Errors.Add(CompilerErrorFactory.NamedParameterMustBeIdentifier(p));
return(false);
}
var members = FindMembers(name);
if (members.Length <= 0)
{
_context.Errors.Add(CompilerErrorFactory.NotAPublicFieldOrProperty(name, name.Name, Type()));
return(false);
}
if (members.Length > 1)
{
_context.Errors.Add(CompilerErrorFactory.AmbiguousReference(name, members));
return(false);
}
var member = members[0];
var property = member as PropertyInfo;
if (property != null)
{
property.SetValue(aa, p.Second, null);
return(true);
}
var field = (FieldInfo)member;
field.SetValue(aa, p.Second);
return(true);
}
public override void OnReferenceExpression(ReferenceExpression node)
{
IEntity entity = NameResolutionService.Resolve(node.Name);
if (entity != null)
{
base.OnReferenceExpression(node);
return;
}
if (node.Name.StartsWith("@"))
{
ReplaceWithComponentReference(node, node.Name);
return;
}
else if (node.ParentNode is ExpressionPair)
{
ExpressionPair pair = (ExpressionPair)node.ParentNode;
StringLiteralExpression literal = CodeBuilder.CreateStringLiteral(node.Name);
pair.Replace(node, literal);
return;
}
else if (
//search for the left side of a key in a hash literal expression
node.ParentNode is ExpressionPair &&
((ExpressionPair)node.ParentNode).First == node &&
node.ParentNode.ParentNode is HashLiteralExpression)
{
ExpressionPair parent = (ExpressionPair)node.ParentNode;
StringLiteralExpression literal = CodeBuilder.CreateStringLiteral(node.Name);
parent.First = literal;
parent.Replace(node, literal);
return;
}
base.OnReferenceExpression(node);
}
public static void AnalyzeLogicalOrExpression(SyntaxNodeAnalysisContext context)
{
SyntaxNode node = context.Node;
if (node.ContainsDiagnostics)
{
return;
}
if (node.SpanContainsDirectives())
{
return;
}
BinaryExpressionInfo info = SyntaxInfo.BinaryExpressionInfo((BinaryExpressionSyntax)context.Node);
if (!info.Success)
{
return;
}
if (!info.Left.IsKind(SyntaxKind.LogicalAndExpression))
{
return;
}
if (!info.Right.IsKind(SyntaxKind.LogicalAndExpression))
{
return;
}
ExpressionPair expressions = GetExpressionPair((BinaryExpressionSyntax)info.Left);
if (!expressions.IsValid)
{
return;
}
ExpressionPair expressions2 = GetExpressionPair((BinaryExpressionSyntax)info.Right);
if (!expressions2.IsValid)
{
return;
}
if (expressions.Expression.Kind() != expressions2.NegatedExpression.Kind())
{
return;
}
if (expressions.NegatedExpression.Kind() != expressions2.Expression.Kind())
{
return;
}
if (!AreEquivalent(expressions.Expression, expressions2.NegatedExpression))
{
return;
}
if (!AreEquivalent(expressions.NegatedExpression, expressions2.Expression))
{
return;
}
context.ReportDiagnostic(DiagnosticDescriptors.UseExclusiveOrOperator, context.Node);
}
protected override void AddResolvedNamedArgumentToEval(MethodInvocationExpression eval, ExpressionPair pair, ReferenceExpression instance)
{
if (!TypeSystemServices.IsQuackBuiltin(pair.First))
{
base.AddResolvedNamedArgumentToEval(eval, pair, instance);
return;
}
MemberReferenceExpression memberRef = new MemberReferenceExpression(
pair.First.LexicalInfo,
instance.CloneNode(),
((ReferenceExpression)pair.First).Name);
BindQuack(memberRef);
eval.Arguments.Add(
CodeBuilder.CreateAssignment(
pair.First.LexicalInfo,
memberRef,
pair.Second));
}
public static CompilerError NamedParameterMustBeIdentifier(ExpressionPair pair)
{
return(new CompilerError("BCE0002", SafeLexicalInfo(pair.First)));
}
public static CompilerError NamedParameterMustBeIdentifier(ExpressionPair pair)
{
return(Instantiate("BCE0002", pair.First));
}
public void Add(ExpressionPair item)
{
base.Add(item);
}
public void Insert(int index, ExpressionPair item)
{
base.Insert(index, item);
}
public override void OnExpressionPair(ExpressionPair node)
{
throw new NotImplementedException();
}
public void Replace(ExpressionPair existing, ExpressionPair newItem)
{
base.Replace(existing, newItem);
}
override public void OnExpressionPair(ExpressionPair pair)
{
Visit(pair.First);
Write(": ");
Visit(pair.Second);
}
public void NamedParameterMustBeReference(ExpressionPair pair)
{
Add(new Error(pair, GetString("NamedParameterMustBeReference")));
}
public override void OnExpressionPair(ExpressionPair node)
{
base.OnExpressionPair(node);
Check(node);
}
public override void OnExpressionPair(ExpressionPair pair)
{
Switch(pair.First);
Write(": ");
Switch(pair.Second);
}
internal CodeAttributeArgument VisitAttributesClosure4(ExpressionPair na)
{
return(new CodeAttributeArgument(na.First.ToString(), this.VisitExpr(na.Second)));
}
