/// <summary> /// Compares two expressions. /// </summary> /// <param name="other">The other expression.</param> protected bool IsExpressionEqual(ICloneOfExpression other) { Debug.Assert(other != null); bool Result = true; Result &= Source == other.Source; return(Result); }
/// <summary> /// Initializes a new instance of the <see cref="CSharpCloneOfExpression"/> class. /// </summary> /// <param name="context">The creation context.</param> /// <param name="source">The Easly expression from which the C# expression is created.</param> protected CSharpCloneOfExpression(ICSharpContext context, ICloneOfExpression source) : base(context, source) { SourceExpression = Create(context, (IExpression)source.Source); IResultType SourceResult = SourceExpression.Source.ResolvedResult.Item; Debug.Assert(SourceResult.Count > 0); foreach (IExpressionType ExpressionType in SourceResult) { ICompiledType ClonedType = ExpressionType.ValueType; ICSharpType Type = CSharpType.Create(context, ClonedType); TypeList.Add(Type); } }
/// <summary> /// Finds the matching nodes of a <see cref="ICloneOfExpression"/>. /// </summary> /// <param name="node">The agent expression to check.</param> /// <param name="errorList">The list of errors found.</param> /// <param name="resolvedResult">The expression result types upon return.</param> /// <param name="resolvedException">Exceptions the expression can throw upon return.</param> /// <param name="constantSourceList">Sources of the constant expression upon return, if any.</param> /// <param name="expressionConstant">The expression constant upon return.</param> public static bool ResolveCompilerReferences(ICloneOfExpression node, IErrorList errorList, out IResultType resolvedResult, out IResultException resolvedException, out ISealableList <IExpression> constantSourceList, out ILanguageConstant expressionConstant) { resolvedResult = null; resolvedException = null; constantSourceList = new SealableList <IExpression>(); expressionConstant = NeutralLanguageConstant.NotConstant; IExpression Source = (IExpression)node.Source; IResultType ResolvedSourceResult = Source.ResolvedResult.Item; foreach (IExpressionType Item in ResolvedSourceResult) { if (Item.ValueType is IClassType AsClassType) { IClass BaseClass = AsClassType.BaseClass; if (BaseClass.Cloneable == BaseNode.CloneableStatus.Cloneable) { AsClassType.MarkAsUsedInCloneOf(); } else { errorList.AddError(new ErrorCloningNotAllowed(node, BaseClass.ValidClassName)); return(false); } } else { errorList.AddError(new ErrorClassTypeRequired(node)); return(false); } } resolvedResult = ResolvedSourceResult; ResultException.Propagate(Source.ResolvedException, out resolvedException); #if COVERAGE Debug.Assert(node.IsComplex); #endif return(true); }
/// <summary> /// Creates a new C# expression. /// </summary> /// <param name="context">The creation context.</param> /// <param name="source">The Easly expression from which the C# expression is created.</param> public static ICSharpCloneOfExpression Create(ICSharpContext context, ICloneOfExpression source) { return(new CSharpCloneOfExpression(context, source)); }