public override void Visit(IMethodCall call) { var receiver = call.ThisArgument; var callee = call.MethodToCall.ResolvedMethod; // Form comparability information for Collection classes if (!call.IsStaticCall && Names.NameTable.ContainsKey(receiver)) { HandleCollectionMethod(call); HandleDictionaryMethod(call); } if (NameBuilder.IsSetter(callee)) { // For setters, mark the property name as comparable with the argument Mark(Expand(new[] { call, call.Arguments.First() })); } if (!(callee is Dummy || callee.Name is Dummy)) { namedCalls.Add(call); } if (!call.IsStaticCall) { PropogateTypeReference(call.ThisArgument, call); } }
/// <summary> /// Tries to find the method that should be called. /// </summary> /// <param name="methodCall">The methodCall can be wrapped</param> /// <returns></returns> protected MethodInfo FindMethodInDomain(IMethodCall methodCall) { foreach (MethodInfo methodInfo in domainService.GetType().GetMethods()) { if (methodCall.MethodName.ToLower() != methodInfo.Name.ToLower()) { continue; } List <ParameterInfo> parameterResult = methodInfo.GetParameters().ToList <ParameterInfo>(); if ((parameterResult.Count != methodCall.Args.Count) && (HelpMethods.AddTrueForSpecified(parameterResult, methodInfo) != methodCall.Args.Count)) { continue; } if (!HelpMethods.TypesAreEqual(methodCall.Classes, parameterResult.ToArray <ParameterInfo>())) { continue; } return(methodInfo); } return(null); }
public TimerJob(IScheduledItem schedule, IMethodCall method, string proFileName) { Schedule = schedule; Method = method; _ExecuteHandler = new ExecuteHandler(ExecuteInternal); ProfileName = proFileName; }
public override void TraverseChildren(IMethodCall methodCall) { if (PhoneCodeHelper.instance().PhoneFeedbackToggled) { // check for handlers we do not wish to add feedback checks to if (methodCall.MethodToCall.Name.Value.StartsWith("add_")) { string eventName = methodCall.MethodToCall.Name.Value.Remove(0, "add_".Length); if (PhoneCodeHelper.IgnoredEvents.Contains(eventName)) { IMethodReference eventHandler = null; foreach (IExpression arg in methodCall.Arguments) { ICreateDelegateInstance createDelegate = arg as ICreateDelegateInstance; if (createDelegate == null) continue; ITypeReference typeRef = createDelegate.Type; if (!typeRef.isRoutedEventHandlerClass(host)) continue; eventHandler = createDelegate.MethodToCallViaDelegate; break; } if (eventHandler != null) { INamespaceTypeReference namedType = eventHandler.ContainingType.ResolvedType as INamespaceTypeReference; if (namedType != null) { INamespaceTypeDefinition namedTypeDef = namedType.ResolvedType; if (namedTypeDef != null) { PhoneCodeHelper.instance().ignoreEventHandler(namedTypeDef.ContainingUnitNamespace.Name + "." + namedTypeDef.Name + "." + eventHandler.Name); } } } } } } }
public override void Visit(IMethodCall methodCall) { _log.Info("Visiting IMethodCall: " + methodCall); var defaultEqualsDefinition = TypeHelper.GetMethod(Host.PlatformType.SystemObject.ResolvedType.Members, Host.NameTable.GetNameFor("Equals"), Host.PlatformType.SystemObject); var methodDefinition = methodCall.MethodToCall.ResolvedMethod; var containingType = methodCall.ThisArgument.Type.ResolvedType; _log.Info("IMethodCall is of " + methodDefinition); //Check if the type overrides the Equals method if (containingType != Host.PlatformType.SystemString && containingType != Host.PlatformType.SystemObject && !containingType.IsValueType && methodDefinition.Equals(defaultEqualsDefinition) && containingType.IsClass && containingType.BaseClasses.Any()) { var overridingMethod = TypeHelper.GetMethod(containingType.Members, Host.NameTable.GetNameFor("Equals"), Host.PlatformType.SystemObject); if (overridingMethod.IsVirtual) { MarkMutationTarget(methodCall); } } }
private bool isKnownUIChanger(ITypeReference typeRef, IMethodCall call) { string methodName = call.MethodToCall.Name.Value; IEnumerable <String> methodsForType = PHONE_UI_CHANGER_METHODS[typeRef.ToString()]; return(methodsForType != null && methodsForType.Contains(methodName)); }
public override void TraverseChildren(IMethodCall methodCall) { if (!IsSharpMockGenerated(methodCall)) { var mutableMethodCall = methodCall as MethodCall; var method = mutableMethodCall.MethodToCall.AsReplaceable(); log.WriteTrace("Finding replacement for {0}.{1}", method.DeclaringType.Name, method.Name); log.WriteTrace(" in '{0}' at '{1}'", method.DeclaringType.Assembly.Name, method.DeclaringType.Assembly.AssemblyPath); if (registry.IsRegistered(method)) { var replacementCall = registry.GetReplacement(method); mutableMethodCall.MethodToCall = replacementCall; if (!methodCall.IsStaticCall) { mutableMethodCall.Arguments.Insert(0, mutableMethodCall.ThisArgument); mutableMethodCall.IsStaticCall = true; mutableMethodCall.IsVirtualCall = false; mutableMethodCall.ThisArgument = CodeDummy.Expression; } log.WriteTrace(" --REPLACEMENT FOUND--"); } else { log.WriteTrace(" --NOT FOUND--"); } } }
public override void Visit(IMethodCall methodCall) { var thisMethod = methodCall.MethodToCall.ResolvedMethod; var currentDefinition = thisMethod.ContainingTypeDefinition; //Find overloads in this class List<IMethodDefinition> allOverloadingMethods = currentDefinition.GetMatchingMembersNamed(thisMethod.Name, false, member => member is IMethodDefinition).Cast<IMethodDefinition>().ToList(); var currentClass = currentDefinition; //Add overloads from base classes while (currentClass.BaseClasses.Any()) { allOverloadingMethods.AddRange(currentClass.BaseClasses.Single() .ResolvedType.GetMatchingMembersNamed(thisMethod.Name, false, member => member is IMethodDefinition).Cast<IMethodDefinition>()); currentClass = currentClass.BaseClasses.Single().ResolvedType; } allOverloadingMethods = allOverloadingMethods.Where(m => !TypeHelper.ParameterListsAreEquivalent(m.Parameters, thisMethod.Parameters)).ToList(); if(allOverloadingMethods.Count > 0) { MarkMutationTarget(methodCall, new MutationVariant("", allOverloadingMethods.First())); } // allOverloadingMethods = allOverloadingMethods.Where(m => // m.Parameters.Count() == thisMethod.Parameters.Count()).ToList(); /* foreach (var method in allOverloadingMethods) { method.Parameters.Di } var types = thisMethod.Parameters.Select(p => p.Type); var sublist = types.ToList().ToSublist(); // sublist. // new[]{4}.ToSublist(). while(List.NextPermutation(sublist)) { } if (method.IsVirtual && method.ContainingTypeDefinition .BaseClasses.Single() .ResolvedType.GetMembersNamed(method.Name, false).Any()) { MarkMutationTarget(method); }*/ }
public override void Visit(IMethodCall methodCall) { var thisMethod = methodCall.MethodToCall.ResolvedMethod; var currentDefinition = thisMethod.ContainingTypeDefinition; //Find overloads in this class List <IMethodDefinition> allOverloadingMethods = currentDefinition.GetMatchingMembersNamed(thisMethod.Name, false, member => member is IMethodDefinition).Cast <IMethodDefinition>().ToList(); var currentClass = currentDefinition; //Add overloads from base classes while (currentClass.BaseClasses.Any()) { allOverloadingMethods.AddRange(currentClass.BaseClasses.Single() .ResolvedType.GetMatchingMembersNamed(thisMethod.Name, false, member => member is IMethodDefinition).Cast <IMethodDefinition>()); currentClass = currentClass.BaseClasses.Single().ResolvedType; } allOverloadingMethods = allOverloadingMethods.Where(m => !TypeHelper.ParameterListsAreEquivalent(m.Parameters, thisMethod.Parameters)).ToList(); if (allOverloadingMethods.Count > 0) { MarkMutationTarget(methodCall, new MutationVariant("", allOverloadingMethods.First())); } // allOverloadingMethods = allOverloadingMethods.Where(m => // m.Parameters.Count() == thisMethod.Parameters.Count()).ToList(); /* foreach (var method in allOverloadingMethods) * { * method.Parameters.Di * } * * * * var types = thisMethod.Parameters.Select(p => p.Type); * var sublist = types.ToList().ToSublist(); * * // sublist. * // new[]{4}.ToSublist(). * while(List.NextPermutation(sublist)) * { * * } * * * * if (method.IsVirtual && method.ContainingTypeDefinition * .BaseClasses.Single() * .ResolvedType.GetMembersNamed(method.Name, false).Any()) * { * MarkMutationTarget(method); * }*/ }
public override void Visit(IMethodCall methodCall) { if (Process(methodCall)) { visitor.Visit(methodCall); } base.Visit(methodCall); }
public override IExpression Rewrite(IMethodCall methodCall) { _log.Info("Rewriting IMethodCall: " + methodCall+" Pass: "+MutationTarget.PassInfo); var equality = new Equality(); equality.LeftOperand = methodCall.ThisArgument; equality.RightOperand = methodCall.Arguments.Single(); equality.Type = Host.PlatformType.SystemBoolean; return equality; }
public override void Visit(IMethodCall call) { var field = TryFindField(call, Parent.CurrentMethod); if (field != null) { MarkMutationTarget(call); } }
public override IExpression Rewrite(IMethodCall methodCall) { _log.Info("Rewriting IMethodCall: " + methodCall + " Pass: " + MutationTarget.PassInfo); var equality = new Equality(); equality.LeftOperand = methodCall.ThisArgument; equality.RightOperand = methodCall.Arguments.Single(); equality.Type = Host.PlatformType.SystemBoolean; return(equality); }
private static IFieldDefinition TryFindField(IMethodCall call, IMethodDefinition currentMethod) { var targetType = call.ThisArgument.Type; var field = currentMethod.ContainingTypeDefinition.Fields .Where(f => f.IsStatic == currentMethod.IsStatic) .FirstOrDefault(f => isCompatibile(targetType, f.Type.ResolvedType) && FieldIsNotThis(f, call.ThisArgument) && !call.MethodToCall.ResolvedMethod.IsConstructor); return field; }
private static IFieldDefinition TryFindField(IMethodCall call, IMethodDefinition currentMethod) { var targetType = call.ThisArgument.Type; var field = currentMethod.ContainingTypeDefinition.Fields .Where(f => f.IsStatic == currentMethod.IsStatic) .FirstOrDefault(f => isCompatibile(targetType, f.Type.ResolvedType) && FieldIsNotThis(f, call.ThisArgument) && !call.MethodToCall.ResolvedMethod.IsConstructor); return(field); }
public bool isNavigationCall(IMethodCall call) { ITypeReference callType = call.MethodToCall.ContainingType; if (!callType.isNavigationServiceClass(host)) { return(false); } return(NAV_CALLS.Contains(call.MethodToCall.Name.Value)); }
public override void Visit(IMethodCall methodCall) { var thisMethod = methodCall.MethodToCall.ResolvedMethod; var types = thisMethod.Parameters.Select(p => p.Type.ResolvedType).ToList(); if (types.Distinct().Count() < thisMethod.Parameters.Count()) { MarkMutationTarget(methodCall); } }
public override IExpression Rewrite(IMethodCall methodCall) { _log.Info("Rewrite IMethodCall: " + OperatorUtils.Formatter.Format(methodCall)); var methodDefinition = TypeHelper.GetMethod(methodCall.MethodToCall.ContainingType.ResolvedType, NameTable.GetNameFor(MutationTarget.PassInfo), methodCall.Arguments.Select(a => a.Type).ToArray()); var newCall = new MethodCall(methodCall); newCall.MethodToCall = methodDefinition;// // (IMethodReference)MutationTarget.StoredObjects.Values.Single(); _log.Info("Returning MethodCall to: " + OperatorUtils.Formatter.Format(methodCall)); return newCall; }
public override void Visit(IMethodCall methodCall) { // I'm going to assume that if it is not a static call then the method makes use of the instance. if (!methodCall.IsStaticCall) { instanceIsUsed = true; return; } base.Visit(methodCall); }
private bool IsSharpMockGenerated(IMethodCall methodCall) { foreach (var customAttribute in methodCall.MethodToCall.ResolvedMethod.Attributes) { if (customAttribute.Constructor.ResolvedMethod.Equals(reflector.From<SharpMockGeneratedAttribute>().GetConstructor(System.Type.EmptyTypes))) { return true; } } return false; }
public override void TraverseChildren(IMethodCall methodCall) { if (methodCall.IsStaticCall || !methodCall.MethodToCall.ContainingType.ResolvedType.Equals(methodBeingTraversed.Container) || methodCall.MethodToCall.Name.Value != "InitializeComponent" || methodCall.Arguments.Any()) { return; } initializationFound = true; }
/// <summary> /// Copy constructor, used by the aggregate web method node /// </summary> /// <param name="methodCall"></param> public MethodCall(IMethodCall methodCall) { m_methodInfo = methodCall.MethodInfo; m_object = Activator.CreateInstance(m_methodInfo.DeclaringType); m_inputType = methodCall.InputType; m_inputSchemas = methodCall.InputSchemas; m_inputSchema = m_inputSchemas[0]; m_outputType = methodCall.OutputType; m_outputSchemas = methodCall.OutputSchemas; m_outputSchema = m_outputSchemas[0]; }
public override void Visit(IMethodCall call) { var field = TryFindField(call, Parent.CurrentMethod); if(field != null) { MarkMutationTarget(call); } }
/// <summary> /// checks whether a static URI root (a definite page base) can be extracted from the expression /// </summary> /// <param name="expr"></param> /// <returns></returns> public static bool IsStaticURIRootExtractable(this IExpression expr, out string uri) { // Pre expr.type == string IMethodCall stringConcatExpr = expr as IMethodCall; uri = null; if (stringConcatExpr == null) { return(false); } if (stringConcatExpr.MethodToCall.Name.Value != "Concat") { return(false); } IList <string> constantStrings = new List <string>(); // TODO this misses so many "static" strings, but let's start with this for now IExpression leftOp = stringConcatExpr.Arguments.FirstOrDefault(); while (leftOp != null && leftOp is ICompileTimeConstant) { ICompileTimeConstant strConst = leftOp as ICompileTimeConstant; constantStrings.Add(strConst.Value as string); if (stringConcatExpr.Arguments.ToList()[1] is IMethodCall) { stringConcatExpr = stringConcatExpr.Arguments.ToList()[1] as IMethodCall; leftOp = stringConcatExpr.Arguments.FirstOrDefault(); } else if (stringConcatExpr.Arguments.ToList()[1] is ICompileTimeConstant) { constantStrings.Add((stringConcatExpr.Arguments.ToList()[1] as ICompileTimeConstant).Value as string); break; } else { break; } } if (constantStrings.Count > 0) { uri = constantStrings.Aggregate((aggr, elem) => aggr + elem); return(Uri.IsWellFormedUriString(uri, UriKind.RelativeOrAbsolute)); } else { return(false); } }
public override void Visit(IMethodCall methodCall) { base.Visit(methodCall); ScannedMethodCalls++; if (_currentTestMethod != null ) { if (_searcher.Matches(methodCall.MethodToCall)) { _log.Debug("Adding test" + _currentTestMethod + " invoking method " + methodCall.MethodToCall); _foundTests.Add(CciMethodMatcher.CreateIdentifier(_currentTestMethod)); } } }
public override void TraverseChildren(IMethodCall methodCall) { var mName = MemberHelper.GetMethodSignature(methodCall.MethodToCall); if (mName.Contains("System.Diagnostics.Contracts.Contract.ForAll")) { base.sourceEmitterOutput.Write("for all "); var n = methodCall.Arguments.Count(); if (n == 2) { var lambda = methodCall.Arguments.ElementAt(1) as IAnonymousDelegate; if (lambda == null) { return; } sourceEmitterOutput.Write(lambda.Parameters.ElementAt(0).Name.Value); sourceEmitterOutput.Write(" in "); Traverse(methodCall.Arguments.ElementAt(0)); sourceEmitterOutput.Write(" "); if (!PrintLambdaBody(lambda)) { Traverse(lambda.Body); } } else { // n == 3 var lambda = methodCall.Arguments.ElementAt(2) as IAnonymousDelegate; if (lambda == null) { return; } var paramName = lambda.Parameters.ElementAt(0).Name.Value; sourceEmitterOutput.Write(paramName); sourceEmitterOutput.Write(" where "); Traverse(methodCall.Arguments.ElementAt(0)); sourceEmitterOutput.Write(" <= "); sourceEmitterOutput.Write(paramName); sourceEmitterOutput.Write(" < "); Traverse(methodCall.Arguments.ElementAt(1)); sourceEmitterOutput.Write(" :: "); if (!PrintLambdaBody(lambda)) { Traverse(lambda.Body); } } return; } base.TraverseChildren(methodCall); }
public override void TraverseChildren(IMethodCall methodCall) { base.TraverseChildren(methodCall); var ps = new List <IParameterTypeInformation>(methodCall.MethodToCall.Parameters); var args = new List <IExpression>(methodCall.Arguments); for (int i = 0, n = args.Count; i < n; i++) { Contract.Assume(args[i] != null); Contract.Assume(i < ps.Count); Contract.Assume(ps[i] != null); args[i] = Convert(args[i], ps[i].Type); } ((MethodCall)methodCall).Type = methodCall.MethodToCall.Type; }
public override void Visit(IMethodCall methodCall) { if(IsPropertyAccessor(methodCall.MethodToCall.ResolvedMethod)) { IMethodDefinition accessor; if(TryGetCompatibileAccessor(methodCall.MethodToCall.ResolvedMethod, out accessor)) { // _log.Info("Marking IMethodCall: " + methodCall.MethodToCall.ResolvedMethod + " - " + methodCall.MethodToCall.ResolvedMethod.GetType()); MarkMutationTarget(methodCall, accessor.Name.Value.InList()); } } }
public void PrintSubVI(int indnt, StreamWriter writer, IMethodCall node) { IEnumerable <INode> E = node.GetDfirRoot.BlockDiagram.GetAllNodes(); indent(indnt, writer); writer.Write("<SubVI NodeId=\"" + node.UniqueId + "\" ParentId=\"" + node.ParentNode.UniqueId + "\">\n"); foreach (var tmp in E) { if (shortName(tmp.GetType().ToString()) == "ExDataAccessor") { IDataAccessor da = tmp as IDataAccessor; ITerminal t = node.GetTerminalByUserVisibleName(da.Name, node.GetDfirRoot); indent(indnt + 1, writer); writer.Write("<Pair TerminalId=\"" + t.UniqueId + "\" SubVIDataAccessorId=\"" + da.UniqueId + "\"/>\n"); } } indent(indnt, writer); writer.Write("</SubVI>\n"); }
public override void TraverseChildren(IMethodCall methodCall) { var mutableMethodCall = methodCall as MethodCall; var callsToOverloads = reflector.From(typeof(Replace)).GetAllOverloadsOf("CallsTo"); if (mutableMethodCall.MethodCallMatchesAnOverload(callsToOverloads)) { var lambda = mutableMethodCall.Arguments[0] as AnonymousDelegate; var parser = new LambdaParser(lambda, host, log, registry); var replacement = parser.GetReplacementFactory(); var registrar = replacement.GetRegistrar(); registrar.RegisterReplacement(); } base.TraverseChildren(methodCall); }
public override void Visit(IMethodCall methodCall) { // _log.Info("Visiting IMethodCall: " + methodCall); /* TypeHelper.GetDefiningUnitReference(methodCall.MethodToCall.ContainingType.ResolvedType); Host.CoreAssemblySymbolicIdentity var namedTypeReference = methodCall.MethodToCall.ContainingType.ResolvedType as INamedTypeReference; if (namedTypeReference != null) { namedTypeReference. }*/ if(IsPropertyModifier(methodCall.MethodToCall.ResolvedMethod)) { IMethodReference accessor; if(TryGetCompatibileModifier(methodCall.MethodToCall.ResolvedMethod, out accessor)) { MarkMutationTarget(methodCall, accessor.Name.Value);//w MutationVariant(accessor.Name.Value, accessor)); } } }
public override IExpression Rewrite(IMethodCall methodCall) { var newSeq = new List<List<Reposition>>(); var thisMethod = methodCall.MethodToCall.ResolvedMethod; var types = thisMethod.Parameters.Select(p => p.Type.ResolvedType).ToList(); var groups = types.Select( (t, i) => new{t,i}).GroupBy(a => a.t, a=>a.i); newSeq.AddRange(from @group in groups select @group.RotateRight(1).Select((i, index) => new Reposition(i, @group.ElementAt(index))).ToList()); var newArgs = new IExpression[types.Count]; foreach (var repos in newSeq.Flatten()) { newArgs[repos.NewPos] = methodCall.Arguments.ElementAt(repos.OldPos); } return new MethodCall(methodCall) { Arguments = newArgs.ToList() }; }
public override IExpression Rewrite(IMethodCall call) { var field = TryFindField(call, CurrentMethod); if (field != null) { return new MethodCall(call) { ThisArgument = new BoundExpression() { Instance = new ThisReference() { Type = CurrentMethod.ContainingTypeDefinition }, Type = field.Type, Definition = field, } }; } else { return call; } }
public void Visit(IMethodCall methodCall) { this.traverser.Traverse(methodCall); }
/// <summary> /// /// </summary> /// <param name="methodCall"></param> internal ConstructorOrMethodCall(IMethodCall methodCall) : base(methodCall) { Contract.Requires(methodCall != null); this.arguments = new List<IExpression>(methodCall.Arguments); this.methodToCall = methodCall.MethodToCall; }
/// <summary> /// /// </summary> /// <param name="methodCall"></param> public MethodCall(IMethodCall methodCall) : base(methodCall) { this.isVirtualCall = methodCall.IsVirtualCall; this.isTailCall = methodCall.IsTailCall; this.isStaticCall = methodCall.IsStaticCall; if (!methodCall.IsStaticCall) { this.thisArgument = methodCall.ThisArgument; } else this.thisArgument = CodeDummy.Expression; //^ assume false; //invariant involves properties }
/// <summary> /// Traverses the children of the method call. /// </summary> public virtual void TraverseChildren(IMethodCall methodCall) { Contract.Requires(methodCall != null); this.TraverseChildren((IExpression)methodCall); if (this.StopTraversal) return; if (!methodCall.IsStaticCall && !methodCall.IsJumpCall) { this.Traverse(methodCall.ThisArgument); if (this.StopTraversal) return; } this.Traverse(methodCall.MethodToCall); if (this.StopTraversal) return; this.Traverse(methodCall.Arguments); }
/// <summary> /// /// </summary> /// <param name="methodCall"></param> /// <remarks>Stub, This one really needs comments!</remarks> public override void Visit(IMethodCall methodCall) { #region Translate In Parameters Bpl.ExprSeq inexpr = new Bpl.ExprSeq(); #region Create the 'this' argument for the function call this.Visit(methodCall.ThisArgument); inexpr.Add(this.TranslatedExpressions.Pop()); #endregion Dictionary<IParameterDefinition, Bpl.Expr> p2eMap = new Dictionary<IParameterDefinition, Bpl.Expr>(); IEnumerator<IParameterDefinition> penum = methodCall.MethodToCall.ResolvedMethod.Parameters.GetEnumerator(); penum.MoveNext(); foreach (IExpression exp in methodCall.Arguments) { if (penum.Current == null) { throw new TranslationException("More Arguments than Parameters in functioncall"); } this.Visit(exp); Bpl.Expr e = this.TranslatedExpressions.Pop(); p2eMap.Add(penum.Current, e); if (!penum.Current.IsOut) { inexpr.Add(e); } penum.MoveNext(); } #endregion Bpl.IToken cloc = methodCall.Token(); // meeting a constructor is always something special if (methodCall.MethodToCall.ResolvedMethod.IsConstructor) { // Todo: do something with the constructor call } else { // Todo: if there is no stmttraverser we are visiting a contract and should use a boogie function instead of procedure! #region Translate Out vars Bpl.IdentifierExprSeq outvars = new Bpl.IdentifierExprSeq(); foreach (KeyValuePair<IParameterDefinition, Bpl.Expr> kvp in p2eMap) { if (kvp.Key.IsOut || kvp.Key.IsByReference) { Bpl.IdentifierExpr iexp = kvp.Value as Bpl.IdentifierExpr; if (iexp == null) { throw new TranslationException("Trying to pass complex expression as out in functioncall"); } outvars.Add(iexp); } } #endregion if (methodCall.Type.ResolvedType.TypeCode != PrimitiveTypeCode.Void) { Bpl.Variable v = this.sink.CreateFreshLocal(methodCall.Type.ResolvedType); outvars.Add(new Bpl.IdentifierExpr(cloc, v)); TranslatedExpressions.Push(new Bpl.IdentifierExpr(cloc, v)); } string methodname = TranslationHelper.CreateUniqueMethodName(methodCall.MethodToCall.ResolvedMethod); this.StmtTraverser.StmtBuilder.Add(new Bpl.CallCmd(cloc, methodname, inexpr, outvars)); } }
public void Visit(IMethodCall methodCall) { throw new NotImplementedException(); }
/// <summary> /// Traverses the children of the method call. /// </summary> public override void TraverseChildren(IMethodCall methodCall) { base.TraverseChildren(methodCall); if (this.StopTraversal) return; if (this.contractProvider == null) return; IEnumerable<IEnumerable<IExpression>>/*?*/ triggers = this.contractProvider.GetTriggersFor(methodCall); if (triggers != null) this.Traverse(triggers); }
public override IExpression Rewrite(IMethodCall methodCall) { var mutableMethodCall = methodCall as MethodCall; if (mutableMethodCall != null) { if (mutableMethodCall.Arguments.Count == 1) { var tokenOf = mutableMethodCall.Arguments[0] as TokenOf; if (tokenOf != null) { var typeRef = tokenOf.Definition as ITypeReference; if (typeRef != null && methodCall.MethodToCall.InternedKey == this.GetTypeFromHandle.InternedKey) { return new TypeOf() { Locations = mutableMethodCall.Locations, Type = methodCall.Type, TypeToGet = typeRef }; } } } } return base.Rewrite(methodCall); }
/// <summary> /// Performs some computation with the given method call. /// </summary> /// <param name="methodCall"></param> public virtual void Visit(IMethodCall methodCall) { this.Visit((IExpression)methodCall); }
public void Visit(IMethodCall methodCall) { Contract.Requires(methodCall != null); throw new NotImplementedException(); }
public override void TraverseChildren(IMethodCall methodCall) { NameFormattingOptions options = NameFormattingOptions.None; bool delegateInvocation = false; if (!methodCall.IsStaticCall && !methodCall.IsJumpCall) { IAddressOf/*?*/ addressOf = methodCall.ThisArgument as IAddressOf; if (addressOf != null) { this.Traverse(addressOf.Expression); } else { this.Traverse(methodCall.ThisArgument); var methodReference = methodCall.MethodToCall; delegateInvocation = methodReference.Name.Value == "Invoke" && methodReference.ContainingType.ResolvedType.IsDelegate; } if (!delegateInvocation) this.PrintToken(CSharpToken.Dot); options |= NameFormattingOptions.OmitContainingNamespace | NameFormattingOptions.OmitContainingType; } else { // it is a static call, so see if it is an operator var methodDefinition = methodCall.MethodToCall.ResolvedMethod; if (IsOperator(methodDefinition) && !IsConversionOperator(methodDefinition)) { var opName = MapOperatorNameToCSharp(methodDefinition); if (opName.Length >= 9) { opName = opName.Substring(9); } if (methodDefinition.ParameterCount == 1) { this.sourceEmitterOutput.Write(opName); this.Traverse(methodCall.Arguments.ElementAt(0)); } else { this.Traverse(methodCall.Arguments.ElementAt(0)); this.sourceEmitterOutput.Write(" "); this.sourceEmitterOutput.Write(opName); this.sourceEmitterOutput.Write(" "); this.Traverse(methodCall.Arguments.ElementAt(1)); } return; } } if (!delegateInvocation) this.PrintMethodReferenceName(methodCall.MethodToCall, options); if (methodCall.MethodToCall.Name.Value.StartsWith("get_")) { if (methodCall.MethodToCall.ParameterCount > 0) { this.sourceEmitterOutput.Write("["); this.Traverse(methodCall.Arguments); this.sourceEmitterOutput.Write("]"); } } else if (methodCall.MethodToCall.Name.Value.StartsWith("set_") && methodCall.MethodToCall.ParameterCount > 0) { var argList = new List<IExpression>(methodCall.Arguments); if (argList.Count > 1) { this.sourceEmitterOutput.Write("["); for (int i = 0, n = argList.Count-1; i < n; i++) { if (i > 0) this.sourceEmitterOutput.Write(", "); this.Traverse(argList[i]); } this.sourceEmitterOutput.Write("]"); } this.sourceEmitterOutput.Write(" = "); this.Traverse(argList[argList.Count-1]); } else this.PrintArgumentList(methodCall.Arguments, methodCall.MethodToCall.Parameters); }
public override void TraverseChildren(IMethodCall methodCall) { var mName = MemberHelper.GetMethodSignature(methodCall.MethodToCall); if (mName.Contains("System.Diagnostics.Contracts.Contract.ForAll")) { base.sourceEmitterOutput.Write("for all "); var n = methodCall.Arguments.Count(); if (n == 2) { var lambda = methodCall.Arguments.ElementAt(1) as IAnonymousDelegate; sourceEmitterOutput.Write(lambda.Parameters.ElementAt(0).Name.Value); sourceEmitterOutput.Write(" in "); Traverse(methodCall.Arguments.ElementAt(0)); sourceEmitterOutput.Write(" "); if (!PrintLambdaBody(lambda)) Traverse(lambda.Body); } else { // n == 3 var lambda = methodCall.Arguments.ElementAt(2) as IAnonymousDelegate; var paramName = lambda.Parameters.ElementAt(0).Name.Value; sourceEmitterOutput.Write(paramName); sourceEmitterOutput.Write(" where "); Traverse(methodCall.Arguments.ElementAt(0)); sourceEmitterOutput.Write(" <= "); sourceEmitterOutput.Write(paramName); sourceEmitterOutput.Write(" < "); Traverse(methodCall.Arguments.ElementAt(1)); sourceEmitterOutput.Write(" :: "); if (!PrintLambdaBody(lambda)) Traverse(lambda.Body); } return; } base.TraverseChildren(methodCall); }
public virtual void onASTElement(IMethodCall methodCall) { }