public static string NewDefinition([NotNull] DefinitionSite definition)
{
switch (definition.kind)
{
case DefinitionSiteKind.RETURN:
return(string.Format("{0}:{1}", definition.kind, definition.method.Name));
case DefinitionSiteKind.NEW:
return(string.Format("INIT:{0}", definition.method.Name));
case DefinitionSiteKind.PARAM:
return(string.Format("{0}({1}):{2}", definition.kind, definition.argIndex, definition.method.Name));
case DefinitionSiteKind.FIELD:
return(string.Format("{0}:{1}", definition.kind, definition.field.Name));
case DefinitionSiteKind.THIS:
case DefinitionSiteKind.CONSTANT:
case DefinitionSiteKind.UNKNOWN:
return(definition.kind.ToString());
default:
throw new ArgumentOutOfRangeException();
}
}
public void RegisterDefinition(string id, DefinitionSite defSite)
{
if (NameResolver.IsExisting(id))
{
var q = NameResolver.Find(id);
q.definition = defSite;
}
}
public void DefinitionByThisIsCorrectInitialized()
{
var actual = DefinitionSites.CreateDefinitionByThis();
var expected = new DefinitionSite
{
kind = DefinitionSiteKind.THIS
};
Assert.AreEqual(expected, actual);
}
public void DefinitionByConstantIsCorrectInitialized()
{
var actual = DefinitionSites.CreateDefinitionByConstant();
var expected = new DefinitionSite
{
kind = DefinitionSiteKind.CONSTANT
};
Assert.AreEqual(expected, actual);
}
public void UnknownDefinitionIsCorrectInitialized()
{
var actual = DefinitionSites.CreateUnknownDefinitionSite();
var expected = new DefinitionSite
{
kind = DefinitionSiteKind.UNKNOWN
};
Assert.AreEqual(expected, actual);
}
public void InitDefinitionIsCorrectInitialized()
{
var actual = DefinitionSites.CreateDefinitionByConstructor("LType.Create()LType;");
var expected = new DefinitionSite
{
kind = DefinitionSiteKind.NEW,
method = new CoReMethodName("LType.Create()LType;")
};
Assert.AreEqual(expected, actual);
}
public void FieldDefinitionIsCorrectInitialized()
{
var actual = DefinitionSites.CreateDefinitionByField("LType.object;LType");
var expected = new DefinitionSite
{
kind = DefinitionSiteKind.FIELD,
field = new CoReFieldName("LType.object;LType")
};
Assert.AreEqual(expected, actual);
}
public void MethodReturnDefinitionIsCorrectInitialized()
{
var actual = DefinitionSites.CreateDefinitionByReturn("LStrangeType.M()LType;");
var expected = new DefinitionSite
{
kind = DefinitionSiteKind.RETURN,
method = new CoReMethodName("LStrangeType.M()LType;")
};
Assert.AreEqual(expected, actual);
}
public void InitDefinitionByMethodNameIsCorrectInitialized()
{
var methodName = Names.Method("[System.Void, mscorlib, 4.0.0.0] [Decl,P1]..ctor()");
var actual = DefinitionSites.CreateDefinitionByConstructor(methodName);
var expected = new DefinitionSite
{
kind = DefinitionSiteKind.NEW,
method = methodName.ToCoReName()
};
Assert.AreEqual(expected, actual);
}
public void FieldDefinitionByFieldNameIsCorrectInitialized()
{
var fieldName = Names.Field("[VType,P1] [Decl,P1]._fieldName");
var actual = DefinitionSites.CreateDefinitionByField(fieldName);
var expected = new DefinitionSite
{
kind = DefinitionSiteKind.FIELD,
field = fieldName.ToCoReName()
};
Assert.AreEqual(expected, actual);
}
public void MethodReturnByMethodNameDefinitionIsCorrectInitialized()
{
var methodName = Names.Method("[RType,P1] [Decl,P1].MethodName()");
var actual = DefinitionSites.CreateDefinitionByReturn(methodName);
var expected = new DefinitionSite
{
kind = DefinitionSiteKind.RETURN,
method = methodName.ToCoReName()
};
Assert.AreEqual(expected, actual);
}
public void ParameterDefinitionIsCorrectInitialized()
{
var actual = DefinitionSites.CreateDefinitionByParam("LType.M(LOtherType;)LType;", 0);
var expected = new DefinitionSite
{
kind = DefinitionSiteKind.PARAM,
method = new CoReMethodName("LType.M(LOtherType;)LType;"),
argIndex = 0
};
Assert.AreEqual(expected, actual);
}
public void ParameterDefinitionByMethodNameIsCorrectInitialized()
{
var methodName = Names.Method("[RType,P1] [Decl,P1].method([PType, Pq1] length)");
var actual = DefinitionSites.CreateDefinitionByParam(methodName, 0);
var expected = new DefinitionSite
{
kind = DefinitionSiteKind.PARAM,
method = methodName.ToCoReName(),
argIndex = 0
};
Assert.AreEqual(expected, actual);
}
private Query CreateQueryWithDefaults(ITypeName type, DefinitionSite def, params IMethodName[] methods)
{
var query = new Query
{
type = type.ToCoReName(),
classCtx = SomeType.ToCoReName(),
methodCtx = SomeMethodName.ToCoReName(),
definition = def
};
foreach (IMethodName method in methods)
{
query.sites.Add(CallSites.CreateReceiverCallSite(method));
}
return(query);
}
private DefinitionSite ReadDefSite(JsonReader reader)
{
var ds = new DefinitionSite();
var obj = JObject.Load(reader);
// kind
var kindToken = obj.GetValue("kind");
var kindStr = kindToken.Value <string>();
DefinitionSiteKind dsk;
Enum.TryParse(kindStr, out dsk);
ds.kind = dsk;
// field
var fieldToken = obj.GetValue("field");
if (fieldToken != null)
{
var fieldStr = fieldToken.Value <string>();
if (fieldStr != null)
{
ds.field = new CoReFieldName(fieldStr);
}
}
// method
var methodToken = obj.GetValue("method");
if (methodToken != null)
{
var methodStr = methodToken.Value <string>();
if (methodStr != null)
{
ds.method = new CoReMethodName(methodStr);
}
}
// argIndex
var argToken = obj.GetValue("argIndex");
if (argToken != null)
{
ds.argIndex = argToken.Value <int>();
}
return(ds);
}
private Query Usage(ITypeName type, DefinitionSite defSite, params string[] calls)
{
var q = new Query
{
type = type.ToCoReName(),
definition = defSite
};
foreach (var shortCall in calls)
{
var mStr = string.Format("[{0}] [{1}].{2}()", "System.Void", "A,P", shortCall);
var m = Names.Method(mStr);
var call = CallSites.CreateReceiverCallSite(m);
q.sites.Add(call);
}
return(q);
}
private Query NewQueryFor(CoReTypeName type, DefinitionSite defSite)
{
var q = new Query();
AllQueries.Add(q);
try
{
q.definition = defSite;
q.type = type;
q.classCtx = Enclosings.Type.ToCoReName();
q.methodCtx = Enclosings.Method.ToCoReName();
return(q);
}
catch (Exception)
{
Console.WriteLine("failed to create new Query, falling back to Unknown");
return(q);
}
}
public void DefineVariable(string id, CoReTypeName type, DefinitionSite defSite)
{
if (NameResolver.IsExistingInCurrentScope(id))
{
return;
}
if (NameResolver.IsExistingInCurrentScope(type))
{
var q = NameResolver.Find(type);
NameResolver.Register(id, q);
}
else
{
var q = NewQueryFor(type, defSite);
NameResolver.Register(id, q);
NameResolver.Register(type, q);
}
}
public void DefinitionSiteSerialization_NullValues()
{
var obj = new DefinitionSite
{
kind = DefinitionSiteKind.THIS,
field = null,
method = null
};
var json = "{" + Environment.NewLine +
" \"kind\": \"THIS\"" + Environment.NewLine +
"}";
var actualJson = obj.ToFormattedJson();
Assert.AreEqual(json, actualJson);
var other = json.ParseJsonTo <DefinitionSite>();
Assert.AreEqual(obj, other);
}
public void DefinitionSiteSerialization_DefaultArgIndexIsNotSerialized()
{
var obj = new DefinitionSite
{
kind = DefinitionSiteKind.THIS,
field = Names.Field("[F,P] [T,P].f").ToCoReName(),
method = Names.Method("[R,P] [T,P].M()").ToCoReName()
};
var json = "{" + Environment.NewLine +
" \"kind\": \"THIS\"," + Environment.NewLine +
" \"field\": \"LT.f;LF\"," + Environment.NewLine +
" \"method\": \"LT.M()LR;\"" + Environment.NewLine +
"}";
var actualJson = obj.ToFormattedJson();
Assert.AreEqual(json, actualJson);
var other = json.ParseJsonTo <DefinitionSite>();
Assert.AreEqual(obj, other);
}
private void Write(JsonWriter writer, DefinitionSite defSite)
{
writer.WriteStartObject();
writer.WritePropertyName("kind");
writer.WriteValue(defSite.kind.ToString());
if (defSite.field != null)
{
writer.WritePropertyName("field");
Write(writer, defSite.field);
}
if (defSite.method != null)
{
writer.WritePropertyName("method");
Write(writer, defSite.method);
}
if (defSite.argIndex != 0)
{
writer.WritePropertyName("argIndex");
writer.WriteValue(defSite.argIndex);
}
writer.WriteEndObject();
}
protected void AssertSingleQueryWithDefinition(DefinitionSite expected)
{
var actual = AssertSingleQuery().definition;
Assert.AreEqual(expected, actual);
}
public void DefineVariable(string id, ITypeName type, DefinitionSite defSite)
{
DefineVariable(id, type.ToCoReName(), defSite);
}
