public void CompletionExpression_OnToken()
{
var sst = new CompletionExpression {
Token = "t"
};
AssertPrint(sst, "t$");
}
public void Equality_Default()
{
var a = new CompletionExpression();
var b = new CompletionExpression();
Assert.AreEqual(a, b);
Assert.AreEqual(a.GetHashCode(), b.GetHashCode());
}
public void CompletionExpression_OnTypeReference_UnresolvedGenericType()
{
var sst = new CompletionExpression
{
TypeReference = Names.Type("T`1[[G]],P")
};
AssertPrint(sst, "T<G>.$");
}
public void CompletionExpression_OnTypeReference()
{
var sst = new CompletionExpression
{
TypeReference = Names.Type("T,P")
};
AssertPrint(sst, "T.$");
}
public void CompletionExpression_OnVariableReference()
{
var sst = new CompletionExpression
{
VariableReference = VarRef("o")
};
AssertPrint(sst, "o.$");
}
public override IAssignableExpression VisitReferenceExpression(IReferenceExpression expr,
IList <IStatement> context)
{
var qualifierExpr = expr.QualifierExpression;
var name = expr.NameIdentifier != null ? expr.NameIdentifier.Name : "";
if (expr == _marker.HandlingNode && _marker.HandlingNode != null)
{
var ce = new CompletionExpression
{
Token = name
};
if (qualifierExpr != null)
{
if (qualifierExpr.IsClassifiedAsVariable ||
qualifierExpr is IInvocationExpression ||
qualifierExpr is IThisExpression ||
qualifierExpr is IBaseExpression)
{
ce.VariableReference = ToVariableRef(qualifierExpr, context);
}
else
{
ce.TypeReference = ToTypeRef(qualifierExpr);
}
}
return(ce);
}
if (IsMember(expr))
{
IVariableReference varRef;
if (IsStatic(expr))
{
varRef = new VariableReference();
}
else
{
varRef = HasImpliciteThis(expr)
? new VariableReference {
Identifier = "this"
}
: ToVariableRef(qualifierExpr, context);
}
return(new ReferenceExpression
{
Reference = GetReference(expr, varRef)
});
}
return(new ReferenceExpression
{
Reference = ToReference(expr, context)
});
}
public void CompletionExpression_OnTypeReferenceWithToken()
{
var sst = new CompletionExpression
{
TypeReference = Names.Type("T,P"),
Token = "t"
};
AssertPrint(sst, "T.t$");
}
public void CompletionExpression_OnVariableReferenceWithToken()
{
var sst = new CompletionExpression
{
VariableReference = VarRef("o"),
Token = "t"
};
AssertPrint(sst, "o.t$");
}
public void DefaultValues()
{
var sut = new CompletionExpression();
Assert.AreEqual("", sut.Token);
Assert.Null(sut.VariableReference);
Assert.Null(sut.TypeReference);
Assert.AreNotEqual(0, sut.GetHashCode());
Assert.AreNotEqual(1, sut.GetHashCode());
}
public void Equality_DifferentObjectReference()
{
var a = new CompletionExpression {
VariableReference = SomeVarRef("i")
};
var b = new CompletionExpression {
VariableReference = SomeVarRef("j")
};
Assert.AreNotEqual(a, b);
Assert.AreNotEqual(a.GetHashCode(), b.GetHashCode());
}
public void ReferenceIsMissing()
{
var expr = new CompletionExpression
{
VariableReference = new VariableReference()
};
var context = new UsageContext();
_sut.Visit(expr, context);
Assert.Null(context.TargetType);
}
public void Equality_DifferentTypeReference()
{
var a = new CompletionExpression {
TypeReference = Names.UnknownType
};
var b = new CompletionExpression {
TypeReference = Names.Type("System.Int32, mscore, 4.0.0.0")
};
Assert.AreNotEqual(a, b);
Assert.AreNotEqual(a.GetHashCode(), b.GetHashCode());
}
public void Equality_DifferentToken()
{
var a = new CompletionExpression {
Token = "t"
};
var b = new CompletionExpression {
Token = "u"
};
Assert.AreNotEqual(a, b);
Assert.AreNotEqual(a.GetHashCode(), b.GetHashCode());
}
public void SettingValues()
{
var sut = new CompletionExpression
{
VariableReference = SomeVarRef("i"),
TypeReference = Names.UnknownType,
Token = "t"
};
Assert.AreEqual(SomeVarRef("i"), sut.VariableReference);
Assert.AreEqual(Names.UnknownType, sut.TypeReference);
Assert.AreEqual("t", sut.Token);
}
public void ReferenceExistsButIsUndefinedInScope()
{
var expr = new CompletionExpression
{
VariableReference = new VariableReference
{
Identifier = "a"
}
};
var context = new UsageContext();
_sut.Visit(expr, context);
Assert.Null(context.TargetType);
}
public void HappyPath()
{
var expr = new CompletionExpression
{
VariableReference = new VariableReference
{
Identifier = "a"
}
};
var context = new UsageContext();
context.DefineVariable("a", Names.Type("T,P"), DefinitionSites.CreateUnknownDefinitionSite());
_sut.Visit(expr, context);
Assert.AreEqual(new CoReTypeName("LT"), context.TargetType);
}
public override void VisitLocalVariableDeclaration(ILocalVariableDeclaration decl, IList <IStatement> body)
{
if (IsTargetMatch(decl, CompletionCase.EmptyCompletionBefore))
{
body.Add(EmptyCompletionExpression);
}
var id = decl.DeclaredName;
ITypeName type;
try
{
type = decl.Type.GetName();
}
catch (AssertException)
{
// TODO this is an intermediate "fix"... the analysis sometimes fails here ("cannot create name for anonymous type")
type = Names.UnknownType;
}
body.Add(SSTUtil.Declare(id, type));
IAssignableExpression initializer = null;
if (decl.Initial != null)
{
initializer = _exprVisitor.ToAssignableExpr(decl.Initial, body);
}
else if (_marker.HandlingNode == decl && _marker.Case == CompletionCase.InBody)
{
initializer = new CompletionExpression();
}
if (initializer != null)
{
if (!IsSelfAssign(id, initializer))
{
body.Add(SSTUtil.AssignmentToLocal(id, initializer));
}
}
if (decl == _marker.HandlingNode && _marker.Case == CompletionCase.EmptyCompletionAfter)
{
body.Add(EmptyCompletionExpression);
}
}
public void Equality_ReallyTheSame()
{
var a = new CompletionExpression
{
VariableReference = SomeVarRef("i"),
Token = "t",
TypeReference = Names.UnknownType
};
var b = new CompletionExpression
{
VariableReference = SomeVarRef("i"),
Token = "t",
TypeReference = Names.UnknownType
};
Assert.AreEqual(a, b);
Assert.AreEqual(a.GetHashCode(), b.GetHashCode());
}
public void VisitorWithReturnIsImplemented()
{
var sut = new CompletionExpression();
sut.Accept(23).VerifyWithReturn(v => v.Visit(sut, 23));
}
public void CompletionExpression_OnNothing()
{
var sst = new CompletionExpression();
AssertPrint(sst, "$");
}
