public void CanUseTagCacheWhileCreatedOnCurrentThread()
{
//-- arrange
TypeMember typeInt = typeof(int);
TypeMember typeString = typeof(string);
RoslynTypeFactoryBackend.BackendTag intTag1;
RoslynTypeFactoryBackend.BackendTag intTag2;
RoslynTypeFactoryBackend.BackendTag stringTag1;
RoslynTypeFactoryBackend.BackendTag stringTag2;
//-- act
using (TypeMemberTagCache.CreateOnCurrentThread())
{
intTag1 = typeInt.SafeBackendTag();
intTag2 = typeInt.SafeBackendTag();
stringTag1 = typeString.SafeBackendTag();
stringTag2 = typeString.SafeBackendTag();
}
//-- assert
intTag1.Should().NotBeNull();
intTag2.Should().BeSameAs(intTag1);
stringTag1.Should().NotBeNull();
stringTag2.Should().BeSameAs(stringTag1);
intTag1.Should().NotBeSameAs(stringTag1);
}
public void BackendTagsArePerInstanceOfTagCache()
{
//-- arrange
TypeMember typeInt = typeof(int);
//-- act
RoslynTypeFactoryBackend.BackendTag tag1;
RoslynTypeFactoryBackend.BackendTag tag2;
using (TypeMemberTagCache.CreateOnCurrentThread())
{
tag1 = typeInt.SafeBackendTag();
}
using (TypeMemberTagCache.CreateOnCurrentThread())
{
tag2 = typeInt.SafeBackendTag();
}
//-- assert
tag1.Should().NotBeNull();
tag2.Should().NotBeNull();
tag2.Should().NotBeSameAs(tag1);
}
//-----------------------------------------------------------------------------------------------------------------------------------------------------
private MemberDeclarationSyntax EmitTypeSyntax(TypeMember type)
{
MemberDeclarationSyntax typeSyntax;
switch (type.TypeKind)
{
case TypeMemberKind.Class:
var classEmitter = new ClassSyntaxEmitter(type);
typeSyntax = classEmitter.EmitSyntax();
break;
case TypeMemberKind.Enum:
var enumEmitter = new EnumSyntaxEmitter(type);
typeSyntax = enumEmitter.EmitSyntax();
break;
default:
throw new NotSupportedException($"TypeMember of kind '{type.TypeKind}' is not supported.");
}
var annotation = new SyntaxAnnotation();
typeSyntax = typeSyntax.WithAdditionalAnnotations(annotation);
type.SafeBackendTag().Annotation = annotation;
return(typeSyntax);
}
public void CannotUseTagCacheIfNotCreatedOnCurrentThread()
{
//-- arrange
TypeMember typeInt = typeof(int);
//-- act & assert
Assert.Throws <InvalidOperationException>(() => {
var tag = typeInt.SafeBackendTag();
});
}
//-----------------------------------------------------------------------------------------------------------------------------------------------------
private static bool IsTypeNamespaceImported(TypeMember type)
{
if (type.SafeBackendTag().IsNamespaceImported)
{
return(true);
}
if (type.IsGenericType && type.GenericTypeDefinition != null)
{
return(IsTypeNamespaceImported(type.GenericTypeDefinition));
}
return(false);
}
public void CannotUseTagCacheAfterItIsDisposedOnCurrentThread()
{
//-- arrange
TypeMember typeInt = typeof(int);
using (TypeMemberTagCache.CreateOnCurrentThread())
{
}
//-- act & assert
Assert.Throws <InvalidOperationException>(() => {
var tag = typeInt.SafeBackendTag();
});
}
//-----------------------------------------------------------------------------------------------------------------------------------------------------
private TextSpan GetTaggedTypeSyntaxSpan(SyntaxTree tree, TypeMember type)
{
var annotation = type.SafeBackendTag().Annotation;
if (annotation != null)
{
var typeSyntax = tree.GetRoot()
.DescendantNodes()
.OfType <ClassDeclarationSyntax>()
.Where(n => n.HasAnnotation(annotation))
.FirstOrDefault();
if (typeSyntax != null)
{
return(typeSyntax.FullSpan);
}
}
return(TextSpan.FromBounds(0, 0));
}
