public void HappyPath()
{
var context = NewContextWithDefaults(
new TypeHierarchy
{
Element = DefaultClassContext
},
new MethodHierarchy
{
Element = DefaultMethodContext
},
VarDecl("A", "a"),
InvokeStmt("a", Method("R", "A", "M")),
Completion("a")
);
var actual = _sut.Extract(context);
var expected = new Query
{
type = Type("A").ToCoReName(),
classCtx = DefaultClassContext.ToCoReName(),
methodCtx = DefaultMethodContext.ToCoReName(),
definition = DefinitionSites.CreateUnknownDefinitionSite(),
sites =
{
CallSites.CreateReceiverCallSite(Method("R", "A", "M"))
}
};
Assert.AreEqual(expected, actual);
}
public void TriggerOnThis_HasBaseClass()
{
var context = NewContextWithDefaults(
new TypeHierarchy
{
Element = DefaultClassContext,
Extends = new TypeHierarchy
{
Element = Type("TSuper")
}
},
new MethodHierarchy
{
Element = DefaultMethodContext
},
InvokeStmt("this", Method("R", "T", "M2")),
Completion("this")
);
var actual = _sut.Extract(context);
var expected = new Query
{
type = Type("TSuper").ToCoReName(),
classCtx = Type("TSuper").ToCoReName(),
methodCtx = DefaultMethodContext.ToCoReName(),
definition = DefinitionSites.CreateDefinitionByThis(),
sites =
{
CallSites.CreateReceiverCallSite(Method("R", "T", "M2"))
}
};
Assert.AreEqual(expected, actual);
}
public void SimpleIntegrationTest()
{
var n = new Network();
n.ReadFile(@"C:\Users\seb\Dropbox\Shared (Mac)\smile-export.xdsl");
var tStringBuilder = new CoReTypeName("LSystem/Text/StringBuilder");
var rec = new SmilePBNRecommender(tStringBuilder, n);
var query = new Query
{
type = tStringBuilder,
classCtx = new CoReTypeName("LCC"),
methodCtx = new CoReMethodName("LMC.m()LV;"),
definition =
DefinitionSites.CreateDefinitionByConstructor("LSystem/Text/StringBuilder.<init>()LSystem/Void;")
};
var call = CallSites.CreateReceiverCallSite("LSystem/Text/StringBuilder.ToString()LSystem/String;");
PrintProposals("before", rec.Query(query));
query.sites.Add(call);
PrintProposals("added ToString", rec.Query(query));
query.sites.Remove(call);
PrintProposals("removed ToString", rec.Query(query));
}
public override DefinitionSite Visit(IInvocationExpression entity,
UsageContext context)
{
try
{
// TODO @seb: fix analysis and then remove this fix
if (Equals("", entity.MethodName.Name))
{
return(DefinitionSites.CreateUnknownDefinitionSite());
}
if (entity.MethodName.IsConstructor)
{
return(DefinitionSites.CreateDefinitionByConstructor(entity.MethodName));
}
return(DefinitionSites.CreateDefinitionByReturn(entity.MethodName));
}
catch (Exception e)
{
// TODO @seb: untested!
Console.WriteLine("UsageDefinitionVisitor: caught exception, falling back to unknown DefinitionSite");
return(DefinitionSites.CreateUnknownDefinitionSite());
}
}
public void AssignmentTest()
{
SetupDefaultEnclosingMethod(
VarDecl("i", Type("I")),
Assign("i", Invoke("this", Method(Type("I"), DefaultClassContext, "M"))),
InvokeStmt("i", SomeMethodOnType("I")));
AssertQueriesInDefault(
new Query
{
type = DefaultClassContext.ToCoReName(),
definition = DefinitionSites.CreateDefinitionByThis(),
sites =
{
CallSites.CreateReceiverCallSite(Method(Type("I"), DefaultClassContext, "M"))
}
},
new Query
{
type = Type("I").ToCoReName(),
definition = DefinitionSites.CreateDefinitionByReturn(Method(Type("I"), DefaultClassContext, "M")),
sites =
{
SomeCallSiteOnType("I")
}
}
);
}
public override void Visit(ITryBlock block, UsageContext context)
{
foreach (var statement in block.Body)
{
statement.Accept(this, context);
}
foreach (var catchBlock in block.CatchBlocks)
{
context.EnterNewScope();
var id = catchBlock.Parameter.Name;
var type = catchBlock.Parameter.ValueType;
var def = DefinitionSites.CreateUnknownDefinitionSite();
context.DefineVariable(id, type, def);
foreach (var statement in catchBlock.Body)
{
statement.Accept(this, context);
}
context.LeaveCurrentScope();
}
foreach (var statement in block.Finally)
{
statement.Accept(this, context);
}
}
public void TryBlockCatchBlockBody()
{
SetupDefaultEnclosingMethod(
VarDecl("a", Type("A")),
new TryBlock
{
CatchBlocks =
{
new CatchBlock
{
Body =
{
InvokeStmt("a", Method(Fix.Void, Type("A"), "M"))
}
}
}
}
);
AssertQueriesInDefault(
new Query
{
type = Type("A").ToCoReName(),
definition = DefinitionSites.CreateUnknownDefinitionSite(),
sites =
{
CallSites.CreateReceiverCallSite(Method(Fix.Void, Type("A"), "M"))
}
});
}
public void RegisterCallsite(string id, IMethodName callsite)
{
// TODO @seb fix analysis and then remove this check!
if (Equals("", callsite.Name))
{
return;
}
if (NameResolver.IsExisting(id))
{
var q = NameResolver.Find(id);
q.sites.Add(CallSites.CreateReceiverCallSite(callsite));
}
else
{
var type = callsite.DeclaringType.ToCoReName();
if (NameResolver.IsExisting(type))
{
var q = NameResolver.Find(type);
q.sites.Add(CallSites.CreateReceiverCallSite(callsite));
}
else
{
var q = NewQueryFor(type, DefinitionSites.CreateUnknownDefinitionSite());
q.sites.Add(CallSites.CreateReceiverCallSite(callsite));
NameResolver.Register(type, q);
}
}
}
public void DefinitionByThis_Base()
{
SetupDefaultEnclosingMethod(
InvokeStmt("base", Method(Fix.Void, DefaultClassContext, "M")));
AssertSingleQueryWithDefinition(DefinitionSites.CreateDefinitionByThis());
}
public void ShouldRecognizeEqualQuerys()
{
var expected = new Query
{
type = new CoReTypeName("LType"),
definition = DefinitionSites.CreateDefinitionByReturn("LFactory.method()LType;"),
classCtx = new CoReTypeName("LClass"),
methodCtx = new CoReMethodName("LReceiver.method(LArgument;)LReturn;")
};
expected.sites.Add(CallSites.CreateParameterCallSite("LReceiver.method(LType;)LReturn;", 3));
expected.sites.Add(CallSites.CreateParameterCallSite("LType.method(LArgument;)LReturn;", 0));
var actual = new Query
{
type = new CoReTypeName("LType"),
definition = DefinitionSites.CreateDefinitionByReturn("LFactory.method()LType;"),
classCtx = new CoReTypeName("LClass"),
methodCtx = new CoReMethodName("LReceiver.method(LArgument;)LReturn;")
};
actual.sites.Add(CallSites.CreateParameterCallSite("LReceiver.method(LType;)LReturn;", 3));
actual.sites.Add(CallSites.CreateParameterCallSite("LType.method(LArgument;)LReturn;", 0));
Assert.AreEqual(expected, actual);
}
public void TryBlockCatchBlockParameter()
{
SetupDefaultEnclosingMethod(
new TryBlock
{
CatchBlocks =
{
new CatchBlock
{
Parameter = Parameter(Type("T"), "p"),
Body =
{
InvokeStmt("p", Method(Fix.Void, Type("T"), "M"))
}
}
}
}
);
AssertQueriesInDefault(
new Query
{
type = Type("T").ToCoReName(),
definition = DefinitionSites.CreateUnknownDefinitionSite(),
sites =
{
CallSites.CreateReceiverCallSite(Method(Fix.Void, Type("T"), "M"))
}
});
}
public void DefinitionNotNullButDefault()
{
var query = new Query();
Assert.NotNull(query.definition);
Assert.AreEqual(DefinitionSites.CreateUnknownDefinitionSite(), query.definition);
}
public void TypeOfThisUsages_SuperTypeIfAvailable()
{
SetupDefaultEnclosingMethod(
InvokeStmt("this", Method(Fix.Void, DefaultClassContext, "M")));
Context.TypeShape.TypeHierarchy = new TypeHierarchy
{
Element = DefaultClassContext,
Extends = new TypeHierarchy
{
Element = Type("TSuper")
}
};
AssertQueriesWithoutSettingContexts(
new Query
{
type = Type("TSuper").ToCoReName(),
classCtx = Type("TSuper").ToCoReName(),
methodCtx = DefaultMethodContext.ToCoReName(),
definition = DefinitionSites.CreateDefinitionByThis(),
sites =
{
CallSites.CreateReceiverCallSite(
Method(Fix.Void, DefaultClassContext, "M"))
}
});
}
public void FieldDefinition()
{
var definition = DefinitionSites.CreateDefinitionByField("LType.object;LType");
var actual = SmilePBNRecommenderConstants.NewDefinition(definition);
const string expected = "FIELD:LType.object;LType";
Assert.AreEqual(expected, actual);
}
public void UnknownDefinition()
{
var definition = DefinitionSites.CreateUnknownDefinitionSite();
var actual = SmilePBNRecommenderConstants.NewDefinition(definition);
const string expected = "UNKNOWN";
Assert.AreEqual(expected, actual);
}
public void ParameterDefinition()
{
var definition = DefinitionSites.CreateDefinitionByParam("LType.M(LOtherType;)LType;", 0);
var actual = SmilePBNRecommenderConstants.NewDefinition(definition);
const string expected = "PARAM(0):LType.M(LOtherType;)LType;";
Assert.AreEqual(expected, actual);
}
public void DefinitionByConstantIsCorrectInitialized()
{
var actual = DefinitionSites.CreateDefinitionByConstant();
var expected = new DefinitionSite
{
kind = DefinitionSiteKind.CONSTANT
};
Assert.AreEqual(expected, actual);
}
public override void Visit(IVariableDeclaration stmt, UsageContext context)
{
if (!stmt.IsMissing)
{
var id = stmt.Reference.Identifier;
var type = stmt.Type;
var def = DefinitionSites.CreateUnknownDefinitionSite();
context.DefineVariable(id, type, def);
}
}
public void VarDefinitionByConstant()
{
SetupDefaultEnclosingMethod(
VarDecl("a", Type("A")),
Assign("a", new ConstantValueExpression()),
InvokeStmt("a", Method(Fix.Void, Type("A"), "M")));
AssertSingleQueryWithType(Type("A"));
AssertSingleQueryWithDefinition(DefinitionSites.CreateDefinitionByConstant());
}
public void UnknownDefinitionIsCorrectInitialized()
{
var actual = DefinitionSites.CreateUnknownDefinitionSite();
var expected = new DefinitionSite
{
kind = DefinitionSiteKind.UNKNOWN
};
Assert.AreEqual(expected, actual);
}
public void DefinitionByThisIsCorrectInitialized()
{
var actual = DefinitionSites.CreateDefinitionByThis();
var expected = new DefinitionSite
{
kind = DefinitionSiteKind.THIS
};
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 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 MethodReturnDefinition()
{
const string name = "LType.M()LType;";
var definition = DefinitionSites.CreateDefinitionByReturn(name);
var actual = SmilePBNRecommenderConstants.NewDefinition(definition);
var expected = string.Format("RETURN:{0}", name);
Assert.AreEqual(expected, actual);
}
public void DefinitionAsParam_Method()
{
var enclosingMethod = Method(Fix.Void, DefaultClassContext, "M", Parameter(Type("P"), "p"));
SetupEnclosingMethod(
enclosingMethod,
InvokeStmt("p", SomeMethodOnType("Q")));
AssertSingleQueryWithType(Type("P"));
AssertSingleQueryWithDefinition(DefinitionSites.CreateDefinitionByParam(enclosingMethod, 0));
}
public void InitDefinition()
{
const string name = "LType.Create()LType;";
var definition = DefinitionSites.CreateDefinitionByConstructor(name);
var actual = SmilePBNRecommenderConstants.NewDefinition(definition);
var expected = String.Format("INIT:{0}", name);
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 VarDefinitionByConstructor_Subtype()
{
var ctor = Constructor(Type("B"));
SetupDefaultEnclosingMethod(
VarDecl("a", Type("A")),
Assign("a", ctor),
InvokeStmt("a", SomeMethodOnType("A")));
AssertSingleQueryWithType(Type("A"));
AssertSingleQueryWithDefinition(DefinitionSites.CreateDefinitionByConstructor(ctor.MethodName));
}
