/// <summary>Visits a constructor invocation.</summary>
/// <param name="cons">Construction.</param>
/// <returns>Resulting expression to visit.</returns>
public override void VisitMethodCall(MethodCall methodCall)
{
if (methodCall != null)
{
MemberBinding callBinding = methodCall.Callee as MemberBinding;
if (callBinding != null)
{
Method method = callBinding.BoundMember as Method;
if (method != null &&
method.DeclaringType.DeclaringModule.ContainingAssembly.Name == "Microsoft.Spatial" &&
method.DeclaringType.FullName == "Microsoft.Spatial.SpatialImplementation" &&
method.Name.Name == "get_Operations" &&
method.IsPublic &&
method.NodeType == NodeType.Method)
{
if (methodUnderCheck.Name.Name != "VerifyAndGetNonNullOperations")
{
this.Problems.Add(new Problem(GetResolution(methodUnderCheck.FullName)));
}
}
}
}
base.VisitMethodCall(methodCall);
}
public async Task<List<PostInfo>> GetRecentPostsAsync(int numposts)
{
Service service = new Service(this.BlogConnectionInfo.MetaWeblogURL);
MethodCall methodCall = new MethodCall("metaWeblog.getRecentPosts");
methodCall.Parameters.Add(this.BlogConnectionInfo.BlogID);
methodCall.Parameters.Add(this.BlogConnectionInfo.Username);
methodCall.Parameters.Add(this.BlogConnectionInfo.Password);
methodCall.Parameters.Add(numposts);
service.Cookies = this.BlogConnectionInfo.Cookies;
MethodResponse methodResponse = await service.ExecuteAsync(methodCall);
Value value = methodResponse.Parameters[0];
XmlRPC.Array array = (XmlRPC.Array)value;
List<PostInfo> list = new List<PostInfo>();
foreach (Value current in array)
{
Struct @struct = (Struct)current;
list.Add(new PostInfo
{
Title = @struct.Get<StringValue>("title", StringValue.NullString).String,
DateCreated = new DateTime?(@struct.Get<DateTimeValue>("dateCreated").Data),
Link = @struct.Get<StringValue>("link", StringValue.NullString).String,
PostID = @struct.Get<StringValue>("postid", StringValue.NullString).String,
UserID = @struct.Get<StringValue>("userid", StringValue.NullString).String,
CommentCount = @struct.Get<IntegerValue>("commentCount", 0).Integer,
PostStatus = @struct.Get<StringValue>("post_status", StringValue.NullString).String,
PermaLink = @struct.Get<StringValue>("permaLink", StringValue.NullString).String,
Description = @struct.Get<StringValue>("description", StringValue.NullString).String
});
}
return list;
}
/// <summary>Visits a method call.</summary>
/// <param name="methodCall">Method call.</param>
/// <returns>Resulting expression to visit.</returns>
public override void VisitMethodCall(MethodCall methodCall)
{
if (methodCall != null)
{
MemberBinding callBinding = methodCall.Callee as MemberBinding;
if (callBinding != null)
{
/*
typeof(DataServiceCollection<>) is compiled to IL as:
ldtoken [Microsoft.OData.Client]Microsoft.OData.Client.DataServiceCollection`1
call class [mscorlib]System.Type [mscorlib]System.Type::GetTypeFromHandle(valuetype [mscorlib]System.RuntimeTypeHandle)
*/
Method method = callBinding.BoundMember as Method;
if (method.Name.Name == "GetTypeFromHandle" &&
method.DeclaringType.FullName == "System.Type")
{
Debug.Assert(methodCall.Operands.Count == 1);
Debug.Assert(methodCall.Operands[0].NodeType == NodeType.Ldtoken);
ClassNode classType = (((Literal)(((UnaryExpression)methodCall.Operands[0]).Operand)).Value) as ClassNode;
if (classType != null && classType.FullName == "Microsoft.OData.Client.DataServiceCollection`1")
{
if (methodUnderCheck.DeclaringType.FullName != "System.Data.Serices.Client.WebUtil" &&
methodUnderCheck.Name.Name != "GetDataServiceCollectionOfTType")
{
this.Problems.Add(new Problem(GetResolution(methodUnderCheck.FullName)));
}
}
}
}
}
base.VisitMethodCall(methodCall);
}
public InterpretedMethod(string name, string [] parameters,IEvaluable body)
{
this.name=name;
this.parameters=parameters;
this.body=body;
this.delegatedMethodCall = null;
}
private static void GenerateMethod()
{
Method method = new Method();
method.Name = "MyNewProc";
method.MethodType = MethodTypeEnum.Void;
Param newParam = new Param();
TypeReferenceExpression newTypeReferenceExpression = new TypeReferenceExpression();
newTypeReferenceExpression.Name = CodeRush.Language.GetSimpleTypeName("System.Int32");
newParam.MemberTypeReference = newTypeReferenceExpression;
newParam.Name = "MyKillerParameter";
method.Parameters.Add(newParam);
MethodCall statement = new MethodCall();
statement.Name = "Start";
//UnaryIncrement newUnaryIncrement = new UnaryIncrement();
//ElementReferenceExpression elementReferenceExpression = new ElementReferenceExpression(newParam.Name);
//newUnaryIncrement.Expression = elementReferenceExpression;
//statement.AddDetailNode(newUnaryIncrement);
//int MyKillerParameter = 0;
//MyKillerParameter++;
method.AddNode(statement);
string newCode = CodeRush.Language.GenerateElement(method);
TextDocument activeTextDocument = CodeRush.Documents.ActiveTextDocument;
if (activeTextDocument == null)
return;
activeTextDocument.InsertText(activeTextDocument.ActiveView.Caret.SourcePoint, newCode);
}
/// <summary>Visits a constructor invocation.</summary>
/// <param name="cons">Construction.</param>
/// <returns>Resulting expression to visit.</returns>
public override void VisitMethodCall(MethodCall methodCall)
{
if (methodCall != null)
{
MemberBinding callBinding = methodCall.Callee as MemberBinding;
if (callBinding != null)
{
Method method = callBinding.BoundMember as Method;
if (method != null &&
method.DeclaringType.FullName == "Microsoft.OData.Client.EntityDescriptor" &&
method.Name.Name != "get_Entity" &&
method.Name.Name != "get_StreamDescriptors" &&
method.Name.Name != "set_ETag" &&
method.IsPublic &&
method.NodeType == NodeType.Method)
{
if (methodUnderCheck.DeclaringType.FullName == "Microsoft.OData.Client.BaseSaveResult" ||
methodUnderCheck.DeclaringType.FullName == "Microsoft.OData.Client.SaveResult")
{
this.Problems.Add(new Problem(GetResolution(methodUnderCheck.FullName)));
}
}
}
}
base.VisitMethodCall(methodCall);
}
public override void VisitMethodCall(MethodCall call)
{
if (call != null)
{
MemberBinding binding = call.Callee as MemberBinding;
Method calleeMethod = (binding == null) ? null : binding.BoundMember as Method;
if (calleeMethod != null)
{
string fullName = calleeMethod.FullName;
if (exploreGraph && alreadyExplored.Add(fullName))
{
// see if the method(s) is is the call graph
Visit(calleeMethod);
}
int hits;
if (this.timesFound.TryGetValue(fullName, out hits))
{
this.timesFound[fullName] = hits + 1;
}
}
}
base.VisitMethodCall(call);
}
public override Statement VisitAssignmentStatement(AssignmentStatement assignment)
{
MemberBinding binding = assignment.Target as MemberBinding;
if (binding != null)
{
Expression target = VisitExpression(binding.TargetObject);
Field boundMember = (Field) binding.BoundMember;
Expression source = VisitExpression(assignment.Source);
if (!boundMember.IsStatic && !boundMember.DeclaringType.IsValueType && boundMember.DeclaringType.Contract != null && boundMember.DeclaringType.Contract.FramePropertyGetter != null && boundMember != boundMember.DeclaringType.Contract.FrameField)
{
Local targetLocal = new Local(boundMember.DeclaringType);
Statement evaluateTarget = new AssignmentStatement(targetLocal, target, assignment.SourceContext);
Local sourceLocal = new Local(boundMember.Type);
Statement evaluateSource = new AssignmentStatement(sourceLocal, source, assignment.SourceContext);
Expression guard = new MethodCall(new MemberBinding(targetLocal, boundMember.DeclaringType.Contract.FramePropertyGetter), null, NodeType.Call, SystemTypes.Guard);
Statement check = new ExpressionStatement(new MethodCall(new MemberBinding(guard, SystemTypes.Guard.GetMethod(Identifier.For("CheckIsWriting"))), null, NodeType.Call, SystemTypes.Void));
Statement stfld = new AssignmentStatement(new MemberBinding(targetLocal, boundMember), sourceLocal, assignment.SourceContext);
return new Block(new StatementList(new Statement[] {evaluateTarget, evaluateSource, check, stfld}));
}
else
{
binding.TargetObject = target;
assignment.Source = source;
return assignment;
}
}
else
{
return base.VisitAssignmentStatement(assignment);
}
}
public override void VisitMethodCall(MethodCall call)
{
var memberBinding = (MemberBinding)call.Callee;
var member = memberBinding.BoundMember;
if (member.NodeType == NodeType.Method)
{
var method = (Method)member;
foreach (var dontPassParameterType in Settings.DontPassParameterType)
{
if (dontPassParameterType.FullName == method.FullName)
{
var infos = Enumerable.Range(1, method.Parameters.Count).GroupJoin(
dontPassParameterType.ParameterType,
index => index,
info => info.Key,
(index, info) => info.FirstOrDefault(i => i.Key == index).Value)
.ToList();
for (var index = 0; index < method.Parameters.Count; index++)
{
string value;
if (dontPassParameterType.ParameterType.TryGetValue(index + 1, out value))
{
if (call.Operands[index].Type.FullName == value)
{
this.Violate(call, method.FullName, index + 1, value);
}
}
}
}
}
}
base.VisitMethodCall(call);
}
private static bool QualifyParameters(MethodCall methodCall)
{
if (methodCall.ArgumentsCount < 1)
return true;
var doubleQuotesExpression = methodCall.Arguments[0] as PrimitiveExpression;
if (doubleQuotesExpression != null
&& doubleQuotesExpression.PrimitiveType == PrimitiveType.String
&& (doubleQuotesExpression.Name == "\"\"" || doubleQuotesExpression.Name == "@\"\""))
return true;
var nullExpression = methodCall.Arguments[0] as PrimitiveExpression;
if (nullExpression != null
&& nullExpression.PrimitiveType == PrimitiveType.Void
&& nullExpression.Name == "null")
return true;
var stringEmptyExpression = methodCall.Arguments[0] as ElementReferenceExpression;
if (stringEmptyExpression != null
&& stringEmptyExpression.Name == "Empty"
&& stringEmptyExpression.Qualifier != null
&& stringEmptyExpression.Qualifier.Name.ToLowerInvariant() == "string")
return true;
return false;
}
protected override Expression VisitMethodCall(MethodCallExpression node)
{
Expression retExpr = null;
if (node.Method.Name == _functionName)
{
var str = node.ToString();
MethodCall call;
if (_methodCalls.TryGetValue(str, out call))
{
++call.CallCount;
}
else
{
call = new MethodCall(node, Expression.Parameter(node.Type, "param" + (_methodCalls.Count)));
_methodCalls.Add(str, call);
}
retExpr = call.Parameter;
}
else
retExpr = base.VisitMethodCall(node);
return retExpr;
}
public void Analyze(MethodCall methodCall, ISymbolTable context, List<IPreCondition> preConditions)
{
Method calleeMethod = IntrospectionUtility.ExtractMethod (methodCall);
ICustomInference matchingRule = MatchingAnalyzeRule (calleeMethod);
if (matchingRule != null)
{
matchingRule.Analyze (methodCall, context, preConditions);
}
}
public override Expression VisitMethodCall(MethodCall call)
{
call.Operands = this.VisitExpressionList(call.Operands);
if (call.Callee != null)
{
call.Callee = this.VisitExpression(call.Callee);
}
return call;
}
public override void VisitMethodCall(MethodCall call) {
Method method = ((MemberBinding)call.Callee).BoundMember as Method;
if ((method != null) &&
(method.DeclaringType.FullName == "System.Script") &&
(method.Name.Name == "Literal")) {
Problems.Add(new Problem(GetResolution(), call.SourceContext));
}
}
public Fragment InferFragmentType(MethodCall methodCall, ISymbolTable context)
{
Fragment returnFragment = Fragment.CreateEmpty();
Method calleeMethod = IntrospectionUtility.ExtractMethod (methodCall);
if(_coveredMethods.Contains(calleeMethod.FullName))
{
returnFragment = ParameterFragmentUtility.ParameterFragmentIntersection (methodCall, context);
}
return returnFragment;
}
public byte[] SerializeMethodCall(MethodCall methodCall)
{
var wrapper = new MethodCallWrapper(methodCall);
wrapper.Args = methodCall.Args;
wrapper.MethodSignature = new string[
methodCall.MethodSignature != null ? methodCall.MethodSignature.Length : 0];
for (int i = 0; i < methodCall.MethodSignature.Length; i++)
wrapper.MethodSignature[i] = this.parseTypeName(methodCall.MethodSignature[i]);
return this.ToJsonBytes(wrapper);
}
public static Fragment ParameterFragmentIntersection(MethodCall methodCall, ISymbolTable context)
{
Fragment current = context.InferFragmentType (methodCall.Operands[0]);
Fragment intersection = current;
for (int i = 1; i < methodCall.Operands.Count; i++)
{
Fragment next = context.InferFragmentType (methodCall.Operands[i]);
intersection = FragmentIntersection (current, next);
}
return intersection;
}
public static bool IsStringConcatMethodCall(MethodCall sourceMethodCall)
{
if (sourceMethodCall == null)
{
return false;
}
var boundMember = ((MemberBinding)sourceMethodCall.Callee).BoundMember;
var isStringConcatMethodCall = boundMember.FullName.StartsWith("System.String.Concat(", StringComparison.OrdinalIgnoreCase);
return isStringConcatMethodCall;
}
public Fragment InferFragmentType(MethodCall methodCall, ISymbolTable context)
{
Fragment fragmentType = Fragment.CreateEmpty();
Method calleeMethod = IntrospectionUtility.ExtractMethod (methodCall);
ICustomInference matchingRule = MatchingInferRule (calleeMethod);
if (matchingRule != null)
{
fragmentType = matchingRule.InferFragmentType (methodCall, context);
}
return fragmentType;
}
public override void VisitMethodCall(MethodCall call)
{
if (call.Method() != null)
{
if (call.Method().Parameters.Any(a => a.Type.FullName == "System.Web.Mvc.JsonRequestBehavior"))
{
this.Problems.Add(new Problem(this.GetResolution(), (Node)call));
}
}
base.VisitMethodCall(call);
}
public override void VisitMethodCall(MethodCall call)
{
if (call.Method() != null)
{
if ((call.Method().Name.Name == "SendMail" || call.Method().Name.Name == "SendBulkMail") && call.Method().DeclaringType.FullName == "CDS.Core.Utils.EMail")
{
Problems.Add(new Problem(this.GetResolution()));
}
}
base.VisitMethodCall(call);
}
private static string GetTypeOfNthParamOfMethod(int ParamIndex, MethodCall MethodCall)
{
MethodReferenceExpression OuterMethodReference = (MethodCall.Nodes[0] as DevExpress.CodeRush.StructuralParser.MethodReferenceExpression);
var Declaration1 = OuterMethodReference.GetDeclaration() as Method;
// Previous line will return null if any parameter isn't explicitly calculable.
if (Declaration1 == null)
return ""; // Suggest void. Wrong, but best available option.
var Param = Declaration1.Parameters[ParamIndex] as Param;
return Param.GetTypeName();
}
public override void VisitMethodCall(MethodCall call)
{
if (call.Method() != null)
{
if (call.Method().IsStatic && call.Method().Name.Name.StartsWith("get_Current")
&& call.Method().DeclaringType.FullName != "System.Globalization.CultureInfo")
{
this.Problems.Add(new Problem(this.GetResolution(call.Method().FullName), (Node)call));
}
}
base.VisitMethodCall(call);
}
private void AddEntryPointMethod(Compilation compilation) {
List<Expression> args = new List<Expression>(1);
args.Add(new CompileTimeConstant(0, SourceDummy.SourceLocation));
Expression createInstance = new CreateObjectInstance(new NamedTypeExpression(new SimpleName(this.Name, SourceDummy.SourceLocation, false)), args, SourceDummy.SourceLocation);
Expression callMain = new MethodCall(
new QualifiedName(createInstance, new SimpleName(compilation.NameTable.GetNameFor("Main"), SourceDummy.SourceLocation, false), SourceDummy.SourceLocation),
Expression.EmptyCollection, SourceDummy.SourceLocation);
List<Statement> body = new List<Statement>(1);
body.Add(new ExpressionStatement(callMain));
MethodDeclaration entryPointMethod = new MethodDeclaration(null, MethodDeclaration.Flags.Static, TypeMemberVisibility.Public,
TypeExpression.For(compilation.PlatformType.SystemVoid.ResolvedType), null, new NameDeclaration(compilation.NameTable.GetNameFor("EntryPoint"), SourceDummy.SourceLocation), null,
null, null, new BlockStatement(body, this.SourceLocation), this.SourceLocation);
this.members.Add(entryPointMethod);
}
private static void CreateMemberCalls()
{
Type csharpArgumentInfoType = Type.GetType(CSharpArgumentInfoTypeName);
Type csharpBinderFlagsType = Type.GetType(CSharpBinderFlagsTypeName);
Type binderType = Type.GetType(BinderTypeName);
Type csharpArgumentInfoTypeEnumerableType = typeof(IEnumerable<>).MakeGenericType(csharpArgumentInfoType);
MethodInfo getMemberMethod = binderType.GetMethod("GetMember", BindingFlags.Public | BindingFlags.Static, null, new[] { csharpBinderFlagsType, typeof(string), typeof(Type), csharpArgumentInfoTypeEnumerableType }, null);
_getMemberCall = JsonTypeReflector.ReflectionDelegateFactory.CreateMethodCall<object>(getMemberMethod);
MethodInfo setMemberMethod = binderType.GetMethod("SetMember", BindingFlags.Public | BindingFlags.Static, null, new[] { csharpBinderFlagsType, typeof(string), typeof(Type), csharpArgumentInfoTypeEnumerableType }, null);
_setMemberCall = JsonTypeReflector.ReflectionDelegateFactory.CreateMethodCall<object>(setMemberMethod);
}
public MethodDefinition(SrcMLArchive archive, MethodData data, MethodCall fromCall) {
this.Archive = archive;
this.SourceCall = fromCall;
this.Data = data;
this.isValid = false;
this.Location = data.PrimaryLocation;
this.FullName = Data.GetFullName();
this.Id = DataHelpers.GetLocation(Location);
this.Path = Location.SourceFileName;
this.Signature = GetMethodSignature();
}
public override void VisitMethodCall(MethodCall call)
{
if (IsSqlExecutingFunction(call.Method()))
{
Problems.Add(new Problem(this.GetResolution(), call.SourceContext));
}
if (!call.Method().DeclaringType.FullName.StartsWith("System.") && !call.Method().DeclaringType.FullName.StartsWith("Microsoft.") && call.Method().DeclaringType != _currentType && call.Method().FullName != "CDS.Core.Utils.Inspection.SafeSqlBuilder.#ctor")
{
Problems.Add(new Problem(this.GetResolution(), call.SourceContext));
}
base.VisitMethodCall(call);
}
internal IWrappedDictionary CreateWrapper(object dictionary)
{
if (dictionary is IDictionary)
return new DictionaryWrapper<object, object>((IDictionary)dictionary);
if (_genericWrapperType == null)
{
_genericWrapperType = ReflectionUtils.MakeGenericType(typeof(DictionaryWrapper<,>), DictionaryKeyType, DictionaryValueType);
ConstructorInfo genericWrapperConstructor = _genericWrapperType.GetConstructor(new[] { _genericCollectionDefinitionType });
_genericWrapperCreator = JsonTypeReflector.ReflectionDelegateFactory.CreateMethodCall<object>(genericWrapperConstructor);
}
return (IWrappedDictionary)_genericWrapperCreator(null, dictionary);
}
public override void VisitMethodCall(MethodCall call)
{
var memberBinding = (MemberBinding)call.Callee;
var member = memberBinding.BoundMember;
if (member.NodeType == NodeType.Method)
{
var method = (Method)member;
if (Settings.DontUseMethod.Contains(method.FullName))
{
this.Violate(call, method.FullName);
}
}
base.VisitMethodCall(call);
}
public override void VisitMethodCall(MethodCall call)
{
if (call.Method() != null)
{
if (!call.Method().DeclaringType.DeclaringModule.ContainingAssembly.IsSystemAssembly() //only need to check our own stuff, we can't do data access through a MSFT function from our web projects
&& call.Method().DeclaringType.DeclaringModule.ContainingAssembly.Name != "CDS.Core.Utils" //MOD: we've whitelisted some stuff, here
&& call.Method().DeclaringType.DeclaringModule.ContainingAssembly.Name != "CDS.ProxyFactory"
&& !call.Method().IsPropertyAccessor()) //call me overconfident, but I think we can assume property accessors aren't writing to the database
{
KeywordViolations(call.Method());
}
}
base.VisitMethodCall(call);
}
public override MethodCall <T, object> CreateMethodCall <T>(MethodBase method)
{
ValidationUtils.ArgumentNotNull(method, "method");
Type type = typeof(object);
ParameterExpression targetParameterExpression = Expression.Parameter(type, "target");
ParameterExpression argsParameterExpression = Expression.Parameter(typeof(object[]), "args");
ParameterInfo[] parametersInfo = method.GetParameters();
Expression[] argsExpression = new Expression[parametersInfo.Length];
for (int i = 0; i < parametersInfo.Length; i++)
{
Expression indexExpression = Expression.Constant(i);
Expression paramAccessorExpression = Expression.ArrayIndex(argsParameterExpression, indexExpression);
paramAccessorExpression = EnsureCastExpression(paramAccessorExpression, parametersInfo[i].ParameterType);
argsExpression[i] = paramAccessorExpression;
}
Expression callExpression;
if (method.IsConstructor)
{
callExpression = Expression.New((ConstructorInfo)method, argsExpression);
}
else if (method.IsStatic)
{
callExpression = Expression.Call((MethodInfo)method, argsExpression);
}
else
{
Expression readParameter = EnsureCastExpression(targetParameterExpression, method.DeclaringType);
callExpression = Expression.Call(readParameter, (MethodInfo)method, argsExpression);
}
if (method is MethodInfo)
{
MethodInfo m = (MethodInfo)method;
if (m.ReturnType != typeof(void))
{
callExpression = EnsureCastExpression(callExpression, type);
}
else
{
callExpression = Expression.Block(callExpression, Expression.Constant(null));
}
}
else
{
callExpression = EnsureCastExpression(callExpression, type);
}
LambdaExpression lambdaExpression = Expression.Lambda(typeof(MethodCall <T, object>), callExpression, targetParameterExpression, argsParameterExpression);
MethodCall <T, object> compiled = (MethodCall <T, object>)lambdaExpression.Compile();
return(compiled);
}
private void AddFactoryMethodArguments(
MethodInfo factory,
MethodCall factoryMethodCall,
List <ApiCall> quotedValues)
{
foreach (var factoryMethodParameter in factory.GetParameters())
{
var parameterName = factoryMethodParameter.Name;
var parameterType = factoryMethodParameter.ParameterType;
ApiCall quotedCodeBlock = FindValue(parameterName, quotedValues);
// special case to prefer SyntaxFactory.IdentifierName("C") to
// SyntaxFactory.IdentifierName(Syntax.Identifier("C"))
if (parameterName == "name" && parameterType == typeof(string))
{
quotedCodeBlock = quotedValues.First(a => a.Name == "Identifier");
var methodCall = quotedCodeBlock.FactoryMethodCall as MethodCall;
if (methodCall != null && methodCall.Name == SyntaxFactory("Identifier"))
{
if (methodCall.Arguments.Count == 1)
{
factoryMethodCall.AddArgument(methodCall.Arguments[0]);
}
else
{
factoryMethodCall.AddArgument(quotedCodeBlock);
}
quotedValues.Remove(quotedCodeBlock);
continue;
}
}
// special case to prefer SyntaxFactory.ClassDeclarationSyntax(string) instead of
// SyntaxFactory.ClassDeclarationSyntax(SyntaxToken)
if (parameterName == "identifier" && parameterType == typeof(string))
{
var methodCall = quotedCodeBlock.FactoryMethodCall as MethodCall;
if (methodCall != null &&
methodCall.Name == SyntaxFactory("Identifier") &&
methodCall.Arguments.Count == 1)
{
factoryMethodCall.AddArgument(methodCall.Arguments[0]);
quotedValues.Remove(quotedCodeBlock);
continue;
}
}
if (quotedCodeBlock != null)
{
factoryMethodCall.AddArgument(quotedCodeBlock);
quotedValues.Remove(quotedCodeBlock);
}
else if (!factoryMethodParameter.IsOptional)
{
throw new InvalidOperationException(
string.Format(
"Couldn't find value for parameter '{0}' of method '{1}'. Go to QuotePropertyValues() and add your node type to the exception list.",
parameterName,
factory));
}
}
}
protected SetupPhrase(MethodCall setup)
{
Debug.Assert(setup != null);
this.setup = setup;
}
public static object ReadMethodCall(BinaryElement elem, BinaryReader reader, bool hasHeaders, HeaderHandler headerHandler, BinaryFormatter formatter)
{
if (elem != BinaryElement.MethodCall)
{
throw new SerializationException("Invalid format. Expected BinaryElement.MethodCall, found " + elem);
}
MethodFlags methodFlags = (MethodFlags)reader.ReadInt32();
if (reader.ReadByte() != 18)
{
throw new SerializationException("Invalid format");
}
string value = reader.ReadString();
if (reader.ReadByte() != 18)
{
throw new SerializationException("Invalid format");
}
string value2 = reader.ReadString();
object[] array = null;
object value3 = null;
object value4 = null;
object[] array2 = null;
Header[] headers = null;
Type[] value5 = null;
if ((methodFlags & MethodFlags.PrimitiveArguments) > (MethodFlags)0)
{
uint num = reader.ReadUInt32();
array = new object[num];
int num2 = 0;
while ((long)num2 < (long)((ulong)num))
{
Type typeFromCode = BinaryCommon.GetTypeFromCode((int)reader.ReadByte());
array[num2] = ObjectReader.ReadPrimitiveTypeValue(reader, typeFromCode);
num2++;
}
}
if ((methodFlags & MethodFlags.NeedsInfoArrayMask) > (MethodFlags)0)
{
ObjectReader objectReader = new ObjectReader(formatter);
object obj;
objectReader.ReadObjectGraph(reader, hasHeaders, out obj, out headers);
object[] array3 = (object[])obj;
if ((methodFlags & MethodFlags.ArgumentsInSimpleArray) > (MethodFlags)0)
{
array = array3;
}
else
{
int num3 = 0;
if ((methodFlags & MethodFlags.ArgumentsInMultiArray) > (MethodFlags)0)
{
if (array3.Length > 1)
{
array = (object[])array3[num3++];
}
else
{
array = new object[0];
}
}
if ((methodFlags & MethodFlags.GenericArguments) > (MethodFlags)0)
{
value5 = (Type[])array3[num3++];
}
if ((methodFlags & MethodFlags.IncludesSignature) > (MethodFlags)0)
{
value3 = array3[num3++];
}
if ((methodFlags & MethodFlags.IncludesLogicalCallContext) > (MethodFlags)0)
{
value4 = array3[num3++];
}
if (num3 < array3.Length)
{
array2 = (object[])array3[num3];
}
}
}
else
{
reader.ReadByte();
}
if (array == null)
{
array = new object[0];
}
string value6 = null;
if (headerHandler != null)
{
value6 = (headerHandler(headers) as string);
}
MethodCall methodCall = new MethodCall(new Header[]
{
new Header("__MethodName", value),
new Header("__MethodSignature", value3),
new Header("__TypeName", value2),
new Header("__Args", array),
new Header("__CallContext", value4),
new Header("__Uri", value6),
new Header("__GenericArguments", value5)
});
if (array2 != null)
{
foreach (DictionaryEntry dictionaryEntry in array2)
{
methodCall.Properties[(string)dictionaryEntry.Key] = dictionaryEntry.Value;
}
}
return(methodCall);
}
public void MethodCall_With_Params_Should_Not_Be_Receive()
{
var methodCall = new MethodCall("", new object[] { 1 });
Assert.False(methodCall.IsReceiveHandlerCall);
}
/// <summary>Gets the workshop value of a macro.</summary>
public static IWorkshopTree CallMacroFunction(ActionSet actionSet, DefinedMethodInstance macro, MethodCall methodCall)
{
actionSet = actionSet.ContainVariableAssigner().PackThis();
// The list containing the macro and all of its overriders, recursively.
var allOptions = new List <MacroOption>();
allOptions.Add(new MacroOption(macro));
// Add overriders to the list.
var relations = new MethodClassRelations(actionSet.ToWorkshop, macro);
if (relations.Overriders != null)
{
allOptions.AddRange(relations.Overriders.Select(overrider => new MacroOption(overrider)));
}
// Add parameters to the assigner.
for (int i = 0; i < macro.ParameterVars.Length; i++)
{
// Origin parameter variables
actionSet.IndexAssigner.Add(macro.ParameterVars[i].Provider, methodCall.ParameterValues[i]);
// Overrider parameter variables.
foreach (var overrider in relations.Overriders)
{
actionSet.IndexAssigner.Add(overrider.ParameterVars[i].Provider, methodCall.ParameterValues[i]);
}
}
// Create the virtual content builder and then return the resulting value.
var virtualContentBuilder = new MacroContentBuilder(actionSet, allOptions);
return(virtualContentBuilder.Value);
}
internal static IMessage DeserializeMessage(String mimeType, Stream xstm, bool methodRequest, IMessage msg, Header[] h)
{
InternalRemotingServices.RemotingTrace("DeserializeMessage");
InternalRemotingServices.RemotingTrace("MimeType: " + mimeType);
CoreChannel.DebugOutXMLStream(xstm, "Deserializing");
Stream fmtStm = null;
bool bin64encode = false;
bool doHeaderBodyAsOne = true;
if (string.Compare(mimeType, BinaryMimeType, StringComparison.Ordinal) == 0)
{
doHeaderBodyAsOne = true;
}
if (string.Compare(mimeType, SOAPMimeType, StringComparison.Ordinal) == 0)
{
doHeaderBodyAsOne = false;
}
if (bin64encode == false)
{
fmtStm = xstm;
}
else
{
InternalRemotingServices.RemotingTrace("***************** Before base64 decode *****");
long Position = xstm.Position;
MemoryStream inStm = (MemoryStream)xstm;
byte[] byteArray = inStm.ToArray();
xstm.Position = Position;
String base64String = Encoding.ASCII.GetString(byteArray, 0, byteArray.Length);
byte[] byteArrayContent = Convert.FromBase64String(base64String);
MemoryStream memStm = new MemoryStream(byteArrayContent);
fmtStm = memStm;
InternalRemotingServices.RemotingTrace("***************** after base64 decode *****");
}
Object ret;
IRemotingFormatter fmt = MimeTypeToFormatter(mimeType, false);
if (doHeaderBodyAsOne == true)
{
ret = ((BinaryFormatter)fmt).UnsafeDeserializeMethodResponse(fmtStm, null, (IMethodCallMessage)msg);
}
else
{
InternalRemotingServices.RemotingTrace("Content");
InternalRemotingServices.RemotingTrace("***************** Before Deserialize Headers *****");
InternalRemotingServices.RemotingTrace("***************** After Deserialize Headers *****");
InternalRemotingServices.RemotingTrace("***************** Before Deserialize Message *****");
if (methodRequest == true)
{
MethodCall mc = new MethodCall(h);
InternalRemotingServices.RemotingTrace("***************** Before Deserialize Message - as MethodCall *****");
fmt.Deserialize(fmtStm, new HeaderHandler(mc.HeaderHandler));
ret = mc;
}
else
{
IMethodCallMessage mcm = (IMethodCallMessage)msg;
MethodResponse mr = new MethodResponse(h, mcm);
InternalRemotingServices.RemotingTrace("***************** Before Deserialize Message - as MethodResponse *****");
fmt.Deserialize(fmtStm, new HeaderHandler(mr.HeaderHandler));
ret = mr;
}
InternalRemotingServices.RemotingTrace("***************** After Deserialize Message *****");
}
// Workaround to make this method verifiable
IMessage resMessage = (IMessage)ret;
InternalRemotingServices.RemotingTrace("CoreChannel::DeserializeMessage OUT");
CoreChannel.DebugMessage(resMessage);
return(resMessage);
}
private MethodBase GetMethodInfo(MethodCall objCall)
{
return(parent.GetMethodInfo(objCall));
}
/// <summary />
public override IStatement Rewrite(IForEachStatement forEachStatement)
{
ILocalDefinition foreachLocal;
var key = forEachStatement.Collection.Type.InternedKey;
ITypeReference enumeratorType;
IMethodReference getEnumerator;
IMethodReference getCurrent;
var gtir = forEachStatement.Collection.Type as IGenericTypeInstanceReference;
if (gtir != null)
{
var typeArguments = gtir.GenericArguments;
ITypeReference genericEnumeratorType = new Immutable.GenericTypeInstanceReference(this.host.PlatformType.SystemCollectionsGenericIEnumerator, typeArguments, this.host.InternFactory);
ITypeReference genericEnumerableType = new Immutable.GenericTypeInstanceReference(this.host.PlatformType.SystemCollectionsGenericIEnumerable, typeArguments, this.host.InternFactory);
enumeratorType = genericEnumeratorType;
getEnumerator = new SpecializedMethodReference()
{
CallingConvention = CallingConvention.HasThis,
ContainingType = genericEnumerableType,
InternFactory = this.host.InternFactory,
Name = this.host.NameTable.GetNameFor("GetEnumerator"),
Parameters = new List <IParameterTypeInformation>(),
Type = genericEnumeratorType,
UnspecializedVersion = new MethodReference()
{
CallingConvention = CallingConvention.HasThis,
ContainingType = this.host.PlatformType.SystemCollectionsGenericIEnumerable,
InternFactory = this.host.InternFactory,
Name = this.host.NameTable.GetNameFor("GetEnumerator"),
Parameters = new List <IParameterTypeInformation>(),
Type = this.host.PlatformType.SystemCollectionsGenericIEnumerator,
},
};
var getEnumerator2 = (IMethodReference)
IteratorHelper.First(genericEnumerableType.ResolvedType.GetMembersNamed(this.host.NameTable.GetNameFor("GetEnumerator"), false));
getEnumerator = getEnumerator2;
getCurrent = (IMethodReference)IteratorHelper.First(genericEnumeratorType.ResolvedType.GetMembersNamed(this.host.NameTable.GetNameFor("get_Current"), false));
}
else
{
enumeratorType = this.host.PlatformType.SystemCollectionsIEnumerator;
getEnumerator = new MethodReference()
{
CallingConvention = CallingConvention.HasThis,
ContainingType = enumeratorType,
InternFactory = this.host.InternFactory,
Name = this.host.NameTable.GetNameFor("GetEnumerator"),
Parameters = new List <IParameterTypeInformation>(),
Type = this.host.PlatformType.SystemCollectionsIEnumerable,
};
getCurrent = new MethodReference()
{
CallingConvention = CallingConvention.HasThis,
ContainingType = enumeratorType,
InternFactory = this.host.InternFactory,
Name = this.host.NameTable.GetNameFor("get_Current"),
Parameters = new List <IParameterTypeInformation>(),
Type = this.host.PlatformType.SystemObject,
};
}
var initializer = new MethodCall()
{
Arguments = new List <IExpression>(),
IsStaticCall = false,
IsVirtualCall = true,
MethodToCall = getEnumerator,
ThisArgument = forEachStatement.Collection,
Type = enumeratorType,
};
IStatement initialization;
if (!this.foreachLocals.TryGetValue(key, out foreachLocal))
{
foreachLocal = new LocalDefinition()
{
Type = enumeratorType, Name = this.host.NameTable.GetNameFor("CS$5$" + this.foreachLocals.Count)
};
this.foreachLocals.Add(key, foreachLocal);
initialization = new LocalDeclarationStatement()
{
InitialValue = initializer,
LocalVariable = foreachLocal,
};
}
else
{
initialization = new ExpressionStatement()
{
Expression = new Assignment()
{
Source = initializer,
Target = new TargetExpression()
{
Definition = foreachLocal,
Instance = null,
Type = foreachLocal.Type,
},
Type = foreachLocal.Type,
},
};
}
var newStmts = new List <IStatement>();
newStmts.Add(new ExpressionStatement()
{
Expression = new Assignment()
{
Source = new MethodCall()
{
Arguments = new List <IExpression>(),
IsStaticCall = false,
IsVirtualCall = true,
MethodToCall = getCurrent,
ThisArgument = new BoundExpression()
{
Definition = foreachLocal,
Instance = null,
},
Type = forEachStatement.Variable.Type,
},
Target = new TargetExpression()
{
Definition = forEachStatement.Variable,
Instance = null,
},
Type = forEachStatement.Variable.Type,
},
});
newStmts.Add(forEachStatement.Body);
var newBody = new BlockStatement()
{
Statements = newStmts,
};
var result = new BlockStatement()
{
Statements = new List <IStatement>()
{
initialization,
new TryCatchFinallyStatement()
{
TryBody = new BlockStatement()
{
Statements = new List <IStatement>()
{
new WhileDoStatement()
{
Body = newBody,
Condition = new MethodCall()
{
Arguments = new List <IExpression>(),
IsStaticCall = false,
IsVirtualCall = true,
MethodToCall = moveNext,
ThisArgument = new BoundExpression()
{
Definition = foreachLocal,
Instance = null,
},
Type = this.host.PlatformType.SystemBoolean,
},
},
},
},
FinallyBody = new BlockStatement()
{
Statements = new List <IStatement>()
{
new ConditionalStatement()
{
Condition = new Equality()
{
LeftOperand = new BoundExpression()
{
Definition = foreachLocal, Instance = null, Type = foreachLocal.Type,
},
RightOperand = new CompileTimeConstant()
{
Type = foreachLocal.Type, Value = null,
},
Type = this.host.PlatformType.SystemBoolean,
},
FalseBranch = new EmptyStatement(),
TrueBranch = new ExpressionStatement()
{
Expression = new MethodCall()
{
Arguments = new List <IExpression>(),
IsStaticCall = false,
IsVirtualCall = true,
MethodToCall = this.disposeMethod,
ThisArgument = new BoundExpression()
{
Definition = foreachLocal,
Instance = null,
},
Type = this.host.PlatformType.SystemVoid,
},
},
},
},
},
},
},
};
return(result);
}
public static ReflectionObject Create(Type t, MethodBase creator, params string[] memberNames)
{
ReflectionDelegateFactory delegateFactory = JsonTypeReflector.ReflectionDelegateFactory;
ObjectConstructor <object> creatorConstructor = null;
if (creator != null)
{
creatorConstructor = delegateFactory.CreateParameterizedConstructor(creator);
}
else
{
if (ReflectionUtils.HasDefaultConstructor(t, false))
{
Func <object> ctor = delegateFactory.CreateDefaultConstructor <object>(t);
creatorConstructor = (id, args) => ctor();
}
}
ReflectionObject d = new ReflectionObject(creatorConstructor);
foreach (string memberName in memberNames)
{
MemberInfo[] members = t.GetMember(memberName, BindingFlags.Instance | BindingFlags.Public);
if (members.Length != 1)
{
throw new ArgumentException("Expected a single member with the name '{0}'.".FormatWith(CultureInfo.InvariantCulture, memberName));
}
MemberInfo member = members.Single();
ReflectionMember reflectionMember = new ReflectionMember();
switch (member.MemberType())
{
case MemberTypes.Field:
case MemberTypes.Property:
if (ReflectionUtils.CanReadMemberValue(member, false))
{
reflectionMember.Getter = delegateFactory.CreateGet <object>(member);
}
if (ReflectionUtils.CanSetMemberValue(member, false, false))
{
reflectionMember.Setter = delegateFactory.CreateSet <object>(member);
}
break;
case MemberTypes.Method:
MethodInfo method = (MethodInfo)member;
if (method.IsPublic)
{
ParameterInfo[] parameters = method.GetParameters();
if (parameters.Length == 0 && method.ReturnType != typeof(void))
{
MethodCall <object, object> call = delegateFactory.CreateMethodCall <object>(method);
reflectionMember.Getter = target => call(target);
}
else if (parameters.Length == 1 && method.ReturnType == typeof(void))
{
MethodCall <object, object> call = delegateFactory.CreateMethodCall <object>(method);
reflectionMember.Setter = (target, arg) => call(target, arg);
}
}
break;
default:
throw new ArgumentException("Unexpected member type '{0}' for member '{1}'.".FormatWith(CultureInfo.InvariantCulture, member.MemberType(), member.Name));
}
if (ReflectionUtils.CanReadMemberValue(member, false))
{
reflectionMember.Getter = delegateFactory.CreateGet <object>(member);
}
if (ReflectionUtils.CanSetMemberValue(member, false, false))
{
reflectionMember.Setter = delegateFactory.CreateSet <object>(member);
}
reflectionMember.MemberType = ReflectionUtils.GetMemberUnderlyingType(member);
d.Members[memberName] = reflectionMember;
}
return(d);
}
public Mnemonic Get(ASTNode?node)
{
Mnemonic result = null;
var symbol = node.Value.Symbol.Name;
switch (symbol)
{
case "assigment":
result = new Assigment(node, this);
break;
case "expression":
result = new Expression(node, this);
break;
case "expression_arg":
case "expression_sum":
case "expression_mult":
case "expression_cmp":
case "expression_bracket":
case "expression_bool":
result = new ExpressionCommon(node, this);
break;
case "expression_prefix":
result = new ExpressionPrefix(node, this);
break;
case "NUMBER":
result = new ValueNumber(node);
break;
case "STRING":
result = new ValueString(node);
break;
case "method_call":
result = new MethodCall(node, this);
break;
case "emptyLine":
result = new Nop(node);
break;
case "variable_name":
result = new VariableName(node, this);
break;
case "if":
result = new If(node, this);
break;
case "block_of_lopla":
result = new Block(node, this);
break;
case "method":
result = new MethodDeclaration(node, this);
break;
case "declare_table":
result = new DeclareTable(node, this);
break;
case "var_value_table":
result = new ValueTable(node, this);
break;
case "while":
result = new While(node, this);
break;
case "return":
result = new Return(node, this);
break;
default:
AddError(
new CompilationError($"{symbol} not handled by compiler. line: {node?.Position.Line}"));
break;
}
return(result);
}
public override Expression VisitMethodCall(MethodCall call)
{
//TODO: add method preconditions to current preconditions
//TODO: treat arguments as assignment statements
return(base.VisitMethodCall(call));
}
public AfterWrappedMethodDelegate BeforeWrappedMethod(Type type, string methodName, string argumentSignature,
object invocationTarget, object[] methodArguments, string tracerFactoryName, string metricName,
uint tracerArguments, ulong functionId)
{
InstrumentedMethodInfo instrumentedMethodInfo = default(InstrumentedMethodInfo);
TrackedWrapper trackedWrapper;
if (_functionIdToWrapper.TryGetValue(functionId, out InstrumentedMethodInfoWrapper methodAndWrapper))
{
instrumentedMethodInfo = methodAndWrapper.instrumentedMethodInfo;
trackedWrapper = methodAndWrapper.wrapper;
}
else
{
var isAsync = TracerArgument.IsAsync(tracerArguments);
tracerFactoryName = ResolveTracerFactoryNameForAttributeInstrumentation(tracerArguments, isAsync, tracerFactoryName);
var method = new Method(type, methodName, argumentSignature, functionId.GetHashCode());
var transactionNamePriority = TracerArgument.GetTransactionNamingPriority(tracerArguments);
instrumentedMethodInfo = new InstrumentedMethodInfo((long)functionId, method, tracerFactoryName, isAsync, metricName, transactionNamePriority, TracerArgument.IsFlagSet(tracerArguments, TracerFlags.WebTransaction));
trackedWrapper = _wrapperMap.Get(instrumentedMethodInfo);
if (trackedWrapper == null)
{
Log.WarnFormat("WrapperMap.Get unexpectedly returned null for {0}.{1}({2}) in assembly [{3}] (requested wrapper name was {4}).",
instrumentedMethodInfo.Method.Type.FullName,
instrumentedMethodInfo.Method.MethodName,
instrumentedMethodInfo.Method.ParameterTypeNames,
instrumentedMethodInfo.Method.Type.Assembly.FullName,
instrumentedMethodInfo.RequestedWrapperName);
return(null);
}
_functionIdToWrapper[functionId] = new InstrumentedMethodInfoWrapper(instrumentedMethodInfo, trackedWrapper);
GenerateLibraryVersionSupportabilityMetric(instrumentedMethodInfo);
}
var wrapper = trackedWrapper.Wrapper;
var transaction = _agent.CurrentTransaction;
if (Log.IsFinestEnabled)
{
transaction.LogFinest($"Attempting to execute {wrapper} found from InstrumentedMethodInfo: {instrumentedMethodInfo}");
}
if (transaction.IsFinished)
{
if (Log.IsFinestEnabled)
{
if (wrapper.IsTransactionRequired)
{
transaction.LogFinest($"Transaction has already ended, skipping method {type.FullName}.{methodName}({argumentSignature}).");
}
else
{
transaction.LogFinest("Transaction has already ended, detaching from transaction storage context.");
}
}
transaction.Detach();
transaction = _agent.CurrentTransaction;
if (wrapper.IsTransactionRequired)
{
return(Delegates.NoOp);
}
}
if (wrapper.IsTransactionRequired)
{
if (!transaction.IsValid)
{
if (Log.IsFinestEnabled)
{
transaction.LogFinest($"No transaction, skipping method {type.FullName}.{methodName}({argumentSignature})");
}
return(Delegates.NoOp);
}
if (transaction.CurrentSegment.IsLeaf)
{
return(Delegates.NoOp);
}
}
var methodCall = new MethodCall(instrumentedMethodInfo.Method, invocationTarget, methodArguments);
var instrumentedMethodCall = new InstrumentedMethodCall(methodCall, instrumentedMethodInfo);
// if the wrapper throws an exception when executing the pre-method code, make sure the wrapper isn't called again in the future
try
{
using (_agentTimerService.StartNew("BeforeWrappedMethod", type.FullName, methodName))
{
var afterWrappedMethod = wrapper.BeforeWrappedMethod(instrumentedMethodCall, _agent, transaction);
return((result, exception) =>
{
using (_agentTimerService.StartNew("AfterWrappedMethod", type.FullName, methodName))
{
// if the wrapper throws an exception when executing the post-method code, make sure the wrapper isn't called again in the future
try
{
afterWrappedMethod(result, exception);
trackedWrapper.NoticeSuccess();
}
catch (Exception)
{
HandleBeforeWrappedMethodException(functionId, trackedWrapper, instrumentedMethodCall, instrumentedMethodInfo);
throw;
}
}
});
}
}
catch
{
HandleBeforeWrappedMethodException(functionId, trackedWrapper, instrumentedMethodCall, instrumentedMethodInfo);
throw;
}
}
/// <summary cref="IValueVisitor.Visit(MethodCall)"/> public void Visit(MethodCall methodCall) => CodeGenerator.GenerateCode(methodCall);
private Expression _PrimaryExpression()
{
if (Current.TokenKind == TokenKind.StringStart)
{
return(_ReadString());
}
else if (Current.TokenKind == TokenKind.ID)
{
Token id = _Consume();
Expression exp = null;
// if ( follows ID, we have a function call
if (Current.TokenKind == TokenKind.LParen)
{
_Consume(); // consume LParen
Expression[] args = _ReadArguments();
_Consume(TokenKind.RParen);
exp = new FCall(id.Line, id.Col, id.Data, args);
}
else // else, we just have id
{
exp = new Name(id.Line, id.Col, id.Data);
}
// while we have ".", keep chaining up field access or method call
while (Current.TokenKind == TokenKind.Dot || Current.TokenKind == TokenKind.LBracket)
{
if (Current.TokenKind == TokenKind.Dot)
{
_Consume(); // consume DOT
Token field = _Consume(TokenKind.ID); // consume ID after dot
// if "(" after ID, then it's a method call
if (Current.TokenKind == TokenKind.LParen)
{
_Consume(); // consume "("
Expression[] args = _ReadArguments();
_Consume(TokenKind.RParen); // read ")"
exp = new MethodCall(field.Line, field.Col, exp, field.Data, args);
}
else
{
exp = new FieldAccess(field.Line, field.Col, exp, field.Data);
}
}
else // must be LBracket
{
// array access
Token bracket = Current;
_Consume(); // consume [
Expression indexExp = _TopExpression();
_Consume(TokenKind.RBracket);
exp = new ArrayAccess(bracket.Line, bracket.Col, exp, indexExp);
}
}
return(exp);
}
else if (Current.TokenKind == TokenKind.Integer)
{
int value = Int32.Parse(Current.Data);
IntLiteral intLiteral = new IntLiteral(Current.Line, Current.Col, value);
_Consume(); // consume int
return(intLiteral);
}
else if (Current.TokenKind == TokenKind.Double)
{
double value = Double.Parse(Current.Data);
DoubleLiteral dLiteral = new DoubleLiteral(Current.Line, Current.Col, value);
_Consume(); // consume int
return(dLiteral);
}
else if (Current.TokenKind == TokenKind.LParen)
{
_Consume(); // eat (
Expression exp = _TopExpression();
_Consume(TokenKind.RParen); // eat )
return(exp);
}
else
{
throw new ParseException("意外的 Token 表达式：" + Current.TokenKind + "。Token类型 即非 ID 也非 string。", Current.Line, Current.Col);
}
}
public void MethodCall_Created_With_Factory_Should_Be_Receive()
{
var methodCall = MethodCall.Receive();
Assert.True(methodCall.IsReceiveHandlerCall);
}
void RegisterEventHandler(MethodCall node, object component)
{
string eventHandlerName = GetEventHandlerName(node);
RegisterEventHandler(component, node.MethodName, eventHandlerName);
}
public FSharpFunction(object?instance, MethodCall <object?, object> invoker)
{
_instance = instance;
_invoker = invoker;
}
private System.Type TypeOfExpr(Expr expr)
{
if (expr is StringLiteral)
{
return(typeof(string));
}
else if (expr is IntLiteral)
{
return(typeof(int));
}
else if (expr is BinExpr)
{
return(TypeOfExpr(((BinExpr)expr).Right));
}
else if (expr is Variable)
{
Variable var = (Variable)expr;
if (this.symbolTable.ContainsKey(var.Ident))
{
Emit.LocalBuilder locb = this.symbolTable[var.Ident];
return(locb.LocalType);
}
else if (this.parameterTable.ContainsKey(var.Ident))
{
return(this.parameterTable[var.Ident]);
}
else if (this.typefieldList.ContainsKey(var.Ident))
{
return(this.typefieldList[var.Ident].FieldType);
}
else
{
throw new System.Exception("undeclared variable '" + var.Ident + "'");
}
}
else if (expr is MethodCall)
{
MethodCall callMethod = (MethodCall)expr;
if (callMethod.returnType == null)
{
if (!callMethod.IsConstrutor)
{
callMethod.returnType = ((MethodInfo)GetMethodInfo(callMethod)).ReturnParameter.ParameterType;
}
else
{
callMethod.returnType = ((System.Reflection.MemberInfo)GetMethodInfo(callMethod)).ReflectedType;
}
// typefieldList = typeof(void);
// callMethod.returnType = ((ConstructorInfo)GetMethodInfo(callMethod)).ReturnParameter.ParameterType;
}
return(callMethod.returnType);
}
else
{
throw new System.Exception("don't know how to calculate the type of " + expr.GetType().Name);
}
}
/// <inheritdoc />
public IFilterFactory <T> NotEquals <TValue>(Expression <Func <T, object> > propertySelector, MethodCall value)
{
_documentQuery.WhereNotEquals(GetFieldName(propertySelector), value);
return(this);
}
private void AddFactoryMethodArguments(
MethodInfo factory,
MethodCall factoryMethodCall,
List <ApiCall> quotedValues)
{
foreach (var factoryMethodParameter in factory.GetParameters())
{
var parameterName = factoryMethodParameter.Name;
var parameterType = factoryMethodParameter.ParameterType;
ApiCall quotedCodeBlock = FindValue(parameterName, quotedValues);
// if we have Block(List<StatementSyntax>(new StatementSyntax[] { A, B })), just simplify it to
// Block(A, B)
if (quotedCodeBlock != null && factory.GetParameters().Length == 1 && factoryMethodParameter.GetCustomAttribute <ParamArrayAttribute>() != null)
{
var methodCall = quotedCodeBlock.FactoryMethodCall as MethodCall;
if (methodCall != null && methodCall.Name.Contains("List") && methodCall.Arguments.Count == 1)
{
var argument = methodCall.Arguments[0] as ApiCall;
var arrayCreation = argument.FactoryMethodCall as MethodCall;
if (argument != null && arrayCreation != null && arrayCreation.Name.StartsWith("new ") && arrayCreation.Name.EndsWith("[]"))
{
foreach (var arrayElement in arrayCreation.Arguments)
{
factoryMethodCall.AddArgument(arrayElement);
}
quotedValues.Remove(quotedCodeBlock);
return;
}
}
}
// special case to prefer SyntaxFactory.IdentifierName("C") to
// SyntaxFactory.IdentifierName(Syntax.Identifier("C"))
if (parameterName == "name" && parameterType == typeof(string))
{
quotedCodeBlock = quotedValues.First(a => a.Name == "Identifier");
var methodCall = quotedCodeBlock.FactoryMethodCall as MethodCall;
if (methodCall != null && methodCall.Name == SyntaxFactoryMethod("Identifier"))
{
if (methodCall.Arguments.Count == 1)
{
factoryMethodCall.AddArgument(methodCall.Arguments[0]);
}
else
{
factoryMethodCall.AddArgument(quotedCodeBlock);
}
quotedValues.Remove(quotedCodeBlock);
continue;
}
}
// special case to prefer SyntaxFactory.ClassDeclarationSyntax(string) instead of
// SyntaxFactory.ClassDeclarationSyntax(SyntaxToken)
if (parameterName == "identifier" && parameterType == typeof(string))
{
var methodCall = quotedCodeBlock.FactoryMethodCall as MethodCall;
if (methodCall != null &&
methodCall.Name == SyntaxFactoryMethod("Identifier") &&
methodCall.Arguments.Count == 1)
{
factoryMethodCall.AddArgument(methodCall.Arguments[0]);
quotedValues.Remove(quotedCodeBlock);
continue;
}
}
if (quotedCodeBlock != null)
{
factoryMethodCall.AddArgument(quotedCodeBlock);
quotedValues.Remove(quotedCodeBlock);
}
else if (!factoryMethodParameter.IsOptional)
{
if (parameterType.IsArray)
{
// assuming this is a params parameter that accepts an array, so if we have nothing we don't need to pass anything
continue;
}
throw new InvalidOperationException(
string.Format(
"Couldn't find value for parameter '{0}' of method '{1}'. Go to QuotePropertyValues() and add your node type to the exception list.",
parameterName,
factory));
}
}
}
public void MethodCall_To_Receive_Should_Be_Receive()
{
var methodCall = new MethodCall("Receive");
Assert.True(methodCall.IsReceiveHandlerCall);
}
public ApiCall(string name, MethodCall factoryMethodCall)
{
Name = name;
FactoryMethodCall = factoryMethodCall;
}
public static ReflectionObject Create(Type t, MethodBase creator, params string[] memberNames)
{
MemberInfo memberInfo;
ReflectionMember reflectionMember;
MemberTypes memberType;
ReflectionDelegateFactory reflectionDelegateFactory = JsonTypeReflector.ReflectionDelegateFactory;
ObjectConstructor <object> objectConstructor = null;
if (creator != null)
{
objectConstructor = reflectionDelegateFactory.CreateParameterizedConstructor(creator);
}
else if (ReflectionUtils.HasDefaultConstructor(t, false))
{
Func <object> func = reflectionDelegateFactory.CreateDefaultConstructor <object>(t);
objectConstructor = (object[] args) => func();
}
ReflectionObject reflectionObject = new ReflectionObject(objectConstructor);
string[] strArrays = memberNames;
for (int i = 0; i < (int)strArrays.Length; i++)
{
string str = strArrays[i];
MemberInfo[] member = t.GetMember(str, BindingFlags.Instance | BindingFlags.Public);
if ((int)member.Length != 1)
{
throw new ArgumentException("Expected a single member with the name '{0}'.".FormatWith(CultureInfo.InvariantCulture, str));
}
memberInfo = ((IEnumerable <MemberInfo>)member).Single <MemberInfo>();
reflectionMember = new ReflectionMember();
memberType = memberInfo.MemberType();
if (memberType != MemberTypes.Field)
{
if (memberType != MemberTypes.Method)
{
goto Label1;
}
MethodInfo methodInfo = (MethodInfo)memberInfo;
if (methodInfo.IsPublic)
{
ParameterInfo[] parameters = methodInfo.GetParameters();
if (parameters.Length == 0 && methodInfo.ReturnType != typeof(void))
{
MethodCall <object, object> methodCall = reflectionDelegateFactory.CreateMethodCall <object>(methodInfo);
reflectionMember.Getter = (object target) => methodCall(target, new object[0]);
}
else if ((int)parameters.Length == 1 && methodInfo.ReturnType == typeof(void))
{
MethodCall <object, object> methodCall1 = reflectionDelegateFactory.CreateMethodCall <object>(methodInfo);
reflectionMember.Setter = (object target, object arg) => methodCall1(target, new object[] { arg });
}
}
}
else
{
goto Label0;
}
Label2:
if (ReflectionUtils.CanReadMemberValue(memberInfo, false))
{
reflectionMember.Getter = reflectionDelegateFactory.CreateGet <object>(memberInfo);
}
if (ReflectionUtils.CanSetMemberValue(memberInfo, false, false))
{
reflectionMember.Setter = reflectionDelegateFactory.CreateSet <object>(memberInfo);
}
reflectionMember.MemberType = ReflectionUtils.GetMemberUnderlyingType(memberInfo);
reflectionObject.Members[str] = reflectionMember;
}
return(reflectionObject);
Label0:
if (ReflectionUtils.CanReadMemberValue(memberInfo, false))
{
reflectionMember.Getter = reflectionDelegateFactory.CreateGet <object>(memberInfo);
}
if (ReflectionUtils.CanSetMemberValue(memberInfo, false, false))
{
reflectionMember.Setter = reflectionDelegateFactory.CreateSet <object>(memberInfo);
goto Label2;
}
else
{
goto Label2;
}
Label1:
if (memberType != MemberTypes.Property)
{
throw new ArgumentException("Unexpected member type '{0}' for member '{1}'.".FormatWith(CultureInfo.InvariantCulture, memberInfo.MemberType(), memberInfo.Name));
}
goto Label0;
}
public static void SetServerIdentity(MethodCall m, object srvID)
{
((IInternalMessage)m).ServerIdentityObject = (ServerIdentity)srvID;
}
public override string ToString()
{
return(MethodCall.ToString());
}
/// <inheritdoc />
public IFilterFactory <T> NotEquals(string fieldName, MethodCall value)
{
_documentQuery.WhereNotEquals(fieldName, (object)value);
return(this);
}
private static void Print(
MemberCall call,
StringBuilder sb,
int depth,
bool openParenthesisOnNewLine = false,
bool closingParenthesisOnNewLine = false,
bool useCurliesInsteadOfParentheses = false)
{
var openParen = useCurliesInsteadOfParentheses ? "{" : "(";
var closeParen = useCurliesInsteadOfParentheses ? "}" : ")";
Print(call.Name, sb, depth);
MethodCall methodCall = call as MethodCall;
if (methodCall != null)
{
if (methodCall.Arguments == null || !methodCall.Arguments.Any())
{
Print(openParen + closeParen, sb, 0);
return;
}
if (openParenthesisOnNewLine)
{
PrintNewLine(sb);
Print(openParen, sb, depth);
}
else
{
Print(openParen, sb, 0);
}
PrintNewLine(sb);
bool needComma = false;
foreach (var block in methodCall.Arguments)
{
if (needComma)
{
Print(",", sb, 0);
PrintNewLine(sb);
}
if (block is string)
{
Print(
(string)block,
sb,
depth + 1);
}
else if (block is SyntaxKind)
{
Print("SyntaxKind." + ((SyntaxKind)block).ToString(), sb, depth + 1);
}
else if (block is ApiCall)
{
Print(
block as ApiCall,
sb,
depth + 1,
openParenthesisOnNewLine: openParenthesisOnNewLine,
closingParenthesisOnNewLine: closingParenthesisOnNewLine);
}
needComma = true;
}
if (closingParenthesisOnNewLine)
{
PrintNewLine(sb);
Print(closeParen, sb, depth);
}
else
{
Print(closeParen, sb, 0);
}
}
}
public static ReflectionObject Create(Type t, MethodBase creator, params string[] memberNames)
{
ReflectionObject obj2 = new ReflectionObject();
ReflectionDelegateFactory reflectionDelegateFactory = JsonTypeReflector.ReflectionDelegateFactory;
if (creator != null)
{
obj2.Creator = reflectionDelegateFactory.CreateParameterizedConstructor(creator);
}
else if (ReflectionUtils.HasDefaultConstructor(t, false))
{
Func <object> ctor = reflectionDelegateFactory.CreateDefaultConstructor <object>(t);
obj2.Creator = args => ctor();
}
foreach (string str in memberNames)
{
MethodInfo info2;
MemberInfo[] source = t.GetMember(str, BindingFlags.Public | BindingFlags.Instance);
if (source.Length != 1)
{
throw new ArgumentException("Expected a single member with the name '{0}'.".FormatWith(CultureInfo.InvariantCulture, str));
}
MemberInfo memberInfo = source.Single <MemberInfo>();
ReflectionMember member = new ReflectionMember();
MemberTypes types = memberInfo.MemberType();
if (types != MemberTypes.Field)
{
if (types == MemberTypes.Method)
{
goto Label_0107;
}
if (types != MemberTypes.Property)
{
throw new ArgumentException("Unexpected member type '{0}' for member '{1}'.".FormatWith(CultureInfo.InvariantCulture, memberInfo.MemberType(), memberInfo.Name));
}
}
if (ReflectionUtils.CanReadMemberValue(memberInfo, false))
{
member.Getter = reflectionDelegateFactory.CreateGet <object>(memberInfo);
}
if (ReflectionUtils.CanSetMemberValue(memberInfo, false, false))
{
member.Setter = reflectionDelegateFactory.CreateSet <object>(memberInfo);
}
goto Label_01F3;
Label_0107:
info2 = (MethodInfo)memberInfo;
if (info2.IsPublic)
{
ParameterInfo[] parameters = info2.GetParameters();
if ((parameters.Length == 0) && (info2.ReturnType != typeof(void)))
{
MethodCall <object, object> call = reflectionDelegateFactory.CreateMethodCall <object>(info2);
member.Getter = target => call(target, new object[0]);
}
else if ((parameters.Length == 1) && (info2.ReturnType == typeof(void)))
{
MethodCall <object, object> call1 = reflectionDelegateFactory.CreateMethodCall <object>(info2);
member.Setter = delegate(object target, object arg) {
object[] args = new object[] { arg };
call1(target, args);
};
}
}
Label_01F3:
if (ReflectionUtils.CanReadMemberValue(memberInfo, false))
{
member.Getter = reflectionDelegateFactory.CreateGet <object>(memberInfo);
}
if (ReflectionUtils.CanSetMemberValue(memberInfo, false, false))
{
member.Setter = reflectionDelegateFactory.CreateSet <object>(memberInfo);
}
member.MemberType = ReflectionUtils.GetMemberUnderlyingType(memberInfo);
obj2.Members[str] = member;
}
return(obj2);
}
private void ControlInvoke(object sender, EventArgs e)
{
MethodCall methodCall = (MethodCall)argumentInvokeList.Dequeue();
methodCall.invoker(methodCall.arguments);
}
