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)); }