/// <summary> /// Creates a new <see cref="CSharpRelationalExpression"/> instance with the /// <paramref name="leftSide"/>, <paramref name="operation"/>, and <paramref name="rightSide"/> /// provided. /// </summary> /// <param name="leftSide">The <see cref="ICSharpRelationalExpression"/> /// which sits on the left side of <paramref name="operation"/>.</param> /// <param name="operation">The <see cref="CSharpRelationalOperation"/> to be performed /// with regards to <paramref name="leftSide"/> and <paramref name="rightSide"/>.</param> /// <param name="rightSide">The <see cref="ICSharpShiftExpression"/> /// which sits on the right-side of <paramref name="operation"/>.</param> /// <exception cref="System.ArgumentNullException">thrown when <paramref name="rightSide"/> is null, or when /// <paramref name="leftSide"/> is null and <paramref name="operation"/> is not /// <see cref="CSharpRelationalOperation.Term"/>.</exception> /// <exception cref="System.ArgumentException">thrown when <paramref name="operation"/> is /// <see cref="CSharpRelationalOperation.TypeCastOrNull"/> or <see cref="CSharpRelationalOperation.TypeCheck"/> /// and <paramref name="rightSide"/> does not <see cref="CSharpExpressionExtensions.Detach(IExpression)"/> /// to an <see cref="ITypeReferenceExpression"/>.</exception> public CSharpRelationalExpression(ICSharpRelationalExpression leftSide, CSharpRelationalOperation operation, ICSharpShiftExpression rightSide) : base(leftSide, rightSide) { if (rightSide == null) { throw new ArgumentNullException("rightSide"); } if (leftSide == null && operation != CSharpRelationalOperation.Term) { throw new ArgumentNullException("leftSide", "Only nullable on term pass-throughs."); } this.operation = operation; switch (operation) { case CSharpRelationalOperation.LessThan: case CSharpRelationalOperation.LessThanOrEqualTo: case CSharpRelationalOperation.GreaterThan: case CSharpRelationalOperation.GreaterThanOrEqualTo: { IExpression detached = rightSide.Detach(); if (detached is ITypeReferenceExpression) { throw ThrowHelper.ObtainArgumentException(ArgumentWithException.rightSide, ExceptionMessageId.RelationalInvalidOnExpression); } break; } case CSharpRelationalOperation.TypeCheck: case CSharpRelationalOperation.TypeCastOrNull: { IExpression detached = rightSide.Detach(); if (!(detached is ITypeReferenceExpression)) { throw ThrowHelper.ObtainArgumentException(ArgumentWithException.rightSide, ExceptionMessageId.TypeRelationalCheckRequiresType, ThrowHelper.GetArgumentName(ArgumentWithException.rightSide)); } ITypeReferenceExpression itre = ((ITypeReferenceExpression)(detached)); if (itre.ReferenceType == null) { throw ThrowHelper.ObtainArgumentException(ArgumentWithException.rightSide, ExceptionMessageId.TypeRelationalTypeCannotBeNull); } if ((!(itre.ReferenceType is IReferenceType)) && (operation == CSharpRelationalOperation.TypeCastOrNull)) { throw ThrowHelper.ObtainArgumentException(ArgumentWithException.rightSide, ExceptionMessageId.TypeRelationalOrNullCastMustBeReference); } break; } case CSharpRelationalOperation.Term: if (leftSide != null) { throw ThrowHelper.ObtainArgumentException(ArgumentWithException.operation, ExceptionMessageId.CannotTermBinaryOperation); } break; default: break; } }
private static void WriteTypeReference(LanguageWriter w, ITypeReferenceExpression exp) { // if(exp.Type.Name=="UnmanagedType")return; // ←何故 UnmanagedType を略すのか不明 if (exp.Type.Name == "<Module>") { return; } new TypeRef(exp.Type).WriteName(w); }
public override bool Visit(ITypeReferenceExpression expression, object context) { _stack.Push(expression); try { return(base.Visit(expression, context)); } finally { _stack.Pop(); } }
private bool ExtendsTheCallerType(IMethodElement method, ITypeElement callerType, Expression qualifier) { if (method == null || callerType == null) { return(false); } if (method.Parameters.Count == 0) { return(false); } ISourceTreeResolver resolver = ParserServices.SourceTreeResolver; ExpressionCollection arguments = new ExpressionCollection(); arguments.Add(qualifier); method = GenericElementActivator.ActivateMemberIfNeeded(resolver, method, arguments, null, ArgumentsHelper.ResolveArgumentTypes(resolver, arguments)) as IMethodElement; if (method == null) { return(false); } IParameterElement extensionParam = method.Parameters[0] as IParameterElement; if (extensionParam == null) { return(false); } ITypeReferenceExpression typeRef = extensionParam.Type; if (typeRef == null) { return(false); } ITypeElement type = typeRef.GetDeclaration() as ITypeElement; if (type == null) { return(false); } IArrayTypeElement arrayType = callerType as IArrayTypeElement; //if (arrayType != null) //{ // return true; //} //else return(ArgumentsHelper.HasParamConversion(resolver, extensionParam, callerType, qualifier, TypeConversionMode.ImplicitConversion)); }
public override bool Equals(object obj) { if (this == obj) { return(true); } ITypeReferenceExpression expression = obj as ITypeReferenceExpression; if (expression == null) { return(false); } return(this.Type.Equals(expression.Type)); }
} // IsElementOfType(DeclaredTypeElement, type) /// <summary> /// Is element of type /// </summary> public bool IsElementOfType(ITypeReferenceExpression declaredTypeExpression, string type) { try { if (declaredTypeExpression == null) { return(false); } if (_NewSourceTreeResolver == null) { _NewSourceTreeResolver = new SourceTreeResolver(); } ITypeElement DeclaredTypeElement = _NewSourceTreeResolver.ResolveExpression(declaredTypeExpression) as ITypeElement; return(IsElementOfType(DeclaredTypeElement, type)); } // try catch (Exception ex) { Trace.WriteLine("Exception in IsElementOfType Function: " + ex.Message); } return(false); } // IsElementOfType(declaredTypeExpression, type)
//============================================================ // 初期化 //============================================================ public AttributeCollection(LanguageWriter writer, ICustomAttributeProvider provider, IType type) { this.writer = writer; this.provider = provider; this.type = type; // 属性の対象 if (provider is IAssembly) { attr_class = "assembly"; isAsmOrModule = true; } else if (provider is IModule) { attr_class = "module"; isAsmOrModule = true; } else if (provider is IMethodReturnType) { attr_class = "returnvalue"; } // 個々の属性に対して走査 foreach (ICustomAttribute attr in provider.Attributes) { if (attr == null) { continue; } string attrname = GetCustomAttributeName(attr); switch (attrname) { case "ParamArray": case "System::ParamArray": containsParams = true; continue; case "MarshalAs": case "System::Runtime::InteropServices::MarshalAs": IExpressionCollection arguments = attr.Arguments; if (arguments == null) { break; } IFieldReferenceExpression exp_fld = arguments[0] as IFieldReferenceExpression; if (exp_fld == null) { break; } ITypeReferenceExpression target = exp_fld.Target as ITypeReferenceExpression; if (target == null || target.Type.Name != "UnmanagedType") { break; } IFieldReference field = exp_fld.Field; if (field.Name == "U1") { if (LanguageWriter.Type(type, "System", "Boolean")) { continue; } } else if (field.Name == "U2" && LanguageWriter.Type(type, "System", "Char")) { continue; } break; } attrs.Add(new AttrPair(attrname, attr)); } // 名前空間順に並び替え attrs.Sort(delegate(AttrPair l, AttrPair r){ string l_name = ((ITypeReference)l.Value.Constructor.DeclaringType).Namespace; string r_name = ((ITypeReference)r.Value.Constructor.DeclaringType).Namespace; return(l_name.CompareTo(r_name)); }); }
public virtual void VisitTypeReferenceExpression(ITypeReferenceExpression value) { VisitType(value.Type); }
public object Evaluate(IExpression expr) { if (expr is IObjectCreateExpression) { return(Evaluate((IObjectCreateExpression)expr)); } else if (expr is ILiteralExpression) { return(((ILiteralExpression)expr).Value); } else if (expr is ICastExpression) { return(Evaluate(((ICastExpression)expr).Expression)); } else if (expr is ICheckedExpression) { return(Evaluate(((ICheckedExpression)expr).Expression)); } else if (expr is IBinaryExpression) { IBinaryExpression ibe = (IBinaryExpression)expr; object left = Evaluate(ibe.Left); object right = Evaluate(ibe.Right); Type type = left.GetType(); return(Microsoft.ML.Probabilistic.Compiler.Reflection.Invoker.InvokeStatic(type, binaryOperatorNames[(int)ibe.Operator], left, right)); } else if (expr is IUnaryExpression) { IUnaryExpression iue = (IUnaryExpression)expr; object target = Evaluate(iue.Expression); Type type = target.GetType(); return(Microsoft.ML.Probabilistic.Compiler.Reflection.Invoker.InvokeStatic(type, unaryOperatorNames[(int)iue.Operator], target)); } else if (expr is IMethodInvokeExpression) { IMethodInvokeExpression imie = (IMethodInvokeExpression)expr; object[] args = EvaluateAll(imie.Arguments); return(Invoke(imie.Method, args)); } else if (expr is IArrayCreateExpression) { IArrayCreateExpression iace = (IArrayCreateExpression)expr; Type t = Builder.ToType(iace.Type); int[] lens = new int[iace.Dimensions.Count]; for (int i = 0; i < lens.Length; i++) { lens[i] = (int)Evaluate(iace.Dimensions[i]); } // TODO: evaluate initializer if (iace.Initializer != null) { throw new NotImplementedException("IArrayCreateExpression has an initializer block"); } return(Array.CreateInstance(t, lens)); } else if (expr is IFieldReferenceExpression) { IFieldReferenceExpression ifre = (IFieldReferenceExpression)expr; if (ifre.Target is ITypeReferenceExpression) { ITypeReferenceExpression itre = (ITypeReferenceExpression)ifre.Target; Type type = Builder.ToType(itre.Type); FieldInfo info = type.GetField(ifre.Field.Name); return(info.GetValue(null)); } else { object target = Evaluate(ifre.Target); FieldInfo info = target.GetType().GetField(ifre.Field.Name); return(info.GetValue(target)); } } else { throw new InferCompilerException("Could not evaluate: " + expr); } }
public virtual void VisitTypeReferenceExpression(ITypeReferenceExpression value) { this.VisitType(value.Type); }
public abstract TransformationImpact CalculateRefactorImpact(ITypeReferenceExpression expression);
public abstract void Translate(ITypeReferenceExpression expression);
private void WriteTypeReferenceExpression(ITypeReferenceExpression expression, IFormatter formatter) { this.WriteTypeReference(expression.Type, formatter); }
public TransformationKind Visit(ITypeReferenceExpression expression, ITransformationContext context) { return(TransformationKind.Investigate); }
public abstract void TranslateExpression(ITypeReferenceExpression typeRefExpression);
public TestLinkerResult Visit(ITypeReferenceExpression expression, ICompilationContext context) { throw new NotImplementedException(); }
TransformationImpact IExpressionVisitor <TransformationImpact> .Visit(ITypeReferenceExpression expression) { return(CalculateRefactorImpact(expression)); }
//=========================================================== // Expression 分岐 //=========================================================== public virtual void WriteExpression(IExpression expression) { if (expression == null) { return; } mwg.Reflector.CppCli.ExpressionWriter.WriteExpression(this, expression, false); #if FALSE #pragma warning disable 612 IMemberInitializerExpression expression3 = expression as IMemberInitializerExpression; if (expression3 != null) { this.WriteMemberInitializerExpression(expression3); return; } IAddressOutExpression expression27 = expression as IAddressOutExpression; if (expression27 != null) { this.WriteAddressOutExpression(expression27); return; } IAddressReferenceExpression expression26 = expression as IAddressReferenceExpression; if (expression26 != null) { this.WriteAddressReferenceExpression(expression26); return; } IDelegateCreateExpression iDelegateCreateExpression = expression as IDelegateCreateExpression; if (iDelegateCreateExpression != null) { this.WriteDelegateCreateExpression(iDelegateCreateExpression); return; } IMethodInvokeExpression iMethodInvokeExpression = expression as IMethodInvokeExpression; if (iMethodInvokeExpression != null) { this.WriteMethodInvokeExpression(iMethodInvokeExpression); return; } IVariableDeclarationExpression expression15 = expression as IVariableDeclarationExpression; if (expression15 != null) { this.WriteVariableDeclaration(expression15.Variable); return; } ITypeOfExpression iTypeOfExpression = expression as ITypeOfExpression; if (iTypeOfExpression != null) { this.WriteTypeOfExpression(iTypeOfExpression); return; } ISnippetExpression iSnippetExpression = expression as ISnippetExpression; if (iSnippetExpression != null) { this.WriteSnippetExpression(iSnippetExpression); return; } IUnaryExpression iUnaryExpression = expression as IUnaryExpression; if (iUnaryExpression != null) { this.WriteUnaryExpression(iUnaryExpression); return; } IObjectCreateExpression iObjectCreateExpression = expression as IObjectCreateExpression; if (iObjectCreateExpression != null) { this.WriteObjectCreateExpression(iObjectCreateExpression); return; } IVariableReferenceExpression iVariableReferenceExpression = expression as IVariableReferenceExpression; if (iVariableReferenceExpression != null) { this.WriteVariableReferenceExpression(iVariableReferenceExpression); return; } IThisReferenceExpression expression12 = expression as IThisReferenceExpression; if (expression12 != null) { this.WriteThisReferenceExpression(expression12); return; } ITryCastExpression iTryCastExpression = expression as ITryCastExpression; if (iTryCastExpression != null) { this.WriteTryCastExpression(iTryCastExpression); return; } IConditionExpression expression9 = expression as IConditionExpression; if (expression9 != null) { this.WriteConditionExpression(expression9); return; } IFieldReferenceExpression iFieldReferenceExpression = expression as IFieldReferenceExpression; if (iFieldReferenceExpression != null) { this.WriteFieldReferenceExpression(iFieldReferenceExpression); return; } IPropertyIndexerExpression iPropertyIndexerExpression = expression as IPropertyIndexerExpression; if (iPropertyIndexerExpression != null) { this.WritePropertyIndexerExpression(iPropertyIndexerExpression); return; } ITypeReferenceExpression iTypeReferenceExpression = expression as ITypeReferenceExpression; if (iTypeReferenceExpression != null) { this.WriteTypeReferenceExpression(iTypeReferenceExpression); return; } IMethodReferenceExpression iMethodReferenceExpression = expression as IMethodReferenceExpression; if (iMethodReferenceExpression != null) { this.WriteMethodReferenceExpression(iMethodReferenceExpression); return; } IPropertyReferenceExpression iPropertyReferenceExpression = expression as IPropertyReferenceExpression; if (iPropertyReferenceExpression != null) { this.WritePropertyReferenceExpression(iPropertyReferenceExpression); return; } ICastExpression expression5 = expression as ICastExpression; if (expression5 != null) { this.WriteCastExpression(expression5); return; } ICanCastExpression iCanCastExpression = expression as ICanCastExpression; if (iCanCastExpression != null) { this.WriteCanCastExpression(iCanCastExpression); return; } ICastExpression iCastExpression = expression as ICastExpression; if (iCastExpression != null) { this.WriteCastExpression(iCastExpression); return; } ILiteralExpression literalExpression = expression as ILiteralExpression; if (literalExpression != null) { this.WriteLiteralExpression(literalExpression); return; } IBinaryExpression iBinaryExpression = expression as IBinaryExpression; if (iBinaryExpression != null) { mwg.Reflector.CppCli.ExpressionWriter.WriteExpression(this, expression, true); //this.WriteBinaryExpression(iBinaryExpression); return; } IArrayIndexerExpression expression30 = expression as IArrayIndexerExpression; if (expression30 != null) { this.WriteArrayIndexerExpression(expression30); return; } IAddressDereferenceExpression expression29 = expression as IAddressDereferenceExpression; if (expression29 != null) { this.WriteAddressDereferenceExpression(expression29); return; } IAddressOfExpression expression28 = expression as IAddressOfExpression; if (expression28 != null) { this.WriteAddressOfExpression(expression28); return; } IArgumentListExpression expression25 = expression as IArgumentListExpression; if (expression25 != null) { this.WriteArgumentListExpression(expression25); return; } IBaseReferenceExpression iBaseReferenceExpression = expression as IBaseReferenceExpression; if (iBaseReferenceExpression != null) { this.WriteBaseReferenceExpression(iBaseReferenceExpression); return; } IArgumentReferenceExpression expression13 = expression as IArgumentReferenceExpression; if (expression13 != null) { this.WriteArgumentReferenceExpression(expression13); return; } IArrayCreateExpression expression10 = expression as IArrayCreateExpression; if (expression10 != null) { this.WriteArrayCreateExpression(expression10); return; } IAssignExpression iAssignExpression = expression as IAssignExpression; if (iAssignExpression != null) { this.WriteAssignExpression(iAssignExpression); return; } IBlockExpression expression2 = expression as IBlockExpression; if (expression2 != null) { this.WriteBlockExpression(expression2); return; } #pragma warning restore 612 this.Write(expression.ToString()); #endif }
void IExpressionVisitor.Visit(ITypeReferenceExpression expression) { this.Translate(expression); }
public override void TranslateExpression(ITypeReferenceExpression typeRefExpression) { this.Provider.GenerateCodeFromExpression(typeRefExpression.GenerateCodeDom(this.Options), base.Target, this.Options.Options); }
public abstract IExpression Transform(ITypeReferenceExpression expression);
} // IsElementOfType(DeclaredTypeElement, type) /// <summary> /// Is element of type /// </summary> public bool IsElementOfType(ITypeReferenceExpression declaredTypeExpression, string type) { try { if (declaredTypeExpression == null) return false; if (_NewSourceTreeResolver == null) _NewSourceTreeResolver = new SourceTreeResolver(); ITypeElement DeclaredTypeElement = _NewSourceTreeResolver.ResolveExpression(declaredTypeExpression) as ITypeElement; return IsElementOfType(DeclaredTypeElement, type); } // try catch (Exception ex) { Trace.WriteLine("Exception in IsElementOfType Function: " + ex.Message); } return false; } // IsElementOfType(declaredTypeExpression, type)
public virtual void VisitTypeReferenceExpression(ITypeReferenceExpression e) { }
public virtual IExpression TransformTypeReferenceExpression(ITypeReferenceExpression value) { return value; }