private DependencyRegistration GetNonFactoryRegistration(IMethodSymbol method, SeparatedSyntaxList <ArgumentSyntax> arguments, SemanticModel semanticModel)
{
ObjectScope scope;
if (!TryGetObjectScope(arguments[0], semanticModel, out scope))
{
return(null);
}
return(DependencyRegistration.NonFactory(
scope,
method.TypeArguments[0],
method.TypeArguments[1]
));
}
internal override DependencyRegistration GetRegistration( IMethodSymbol method, SeparatedSyntaxList<ArgumentSyntax> arguments, SemanticModel semanticModel ) {
if( arguments.Count != 1 ) {
return null;
}
ObjectScope scope;
if( !TryGetObjectScope( arguments[0], semanticModel, out scope ) ) {
return null;
}
return DependencyRegistration.NonFactory(
scope: scope,
dependencyType: method.TypeArguments[0],
concreteType: method.TypeArguments[0]
);
}
internal override DependencyRegistration GetRegistration(
IMethodSymbol method,
SeparatedSyntaxList <ArgumentSyntax> arguments,
SemanticModel semanticModel
)
{
ITypeSymbol concreteType = GetConstructedTypeOfIFactory(
semanticModel,
method.TypeArguments[0],
method.TypeArguments[1]
);
return(DependencyRegistration.Factory(
ObjectScope.AlwaysCreateNewInstance,
method.TypeArguments[0],
method.TypeArguments[1],
concreteType
));
}
internal override DependencyRegistration GetRegistration(IMethodSymbol method, SeparatedSyntaxList <ArgumentSyntax> arguments, SemanticModel semanticModel)
{
if (arguments.Count != 1)
{
return(null);
}
ObjectScope scope;
if (!TryGetObjectScope(arguments[0], semanticModel, out scope))
{
return(null);
}
return(DependencyRegistration.DynamicObjectFactory(
scope: scope,
dependencyType: WrapWithIFactoryType(method.TypeArguments[0], semanticModel.Compilation),
dynamicObjectType: method.TypeArguments[1]
));
}
private DependencyRegistration GetFactoryRegistration(IMethodSymbol method, SeparatedSyntaxList <ArgumentSyntax> arguments, SemanticModel semanticModel)
{
ObjectScope scope;
if (!TryGetObjectScope(arguments[0], semanticModel, out scope))
{
return(null);
}
ITypeSymbol concreteType = GetConstructedTypeOfIFactory(
semanticModel,
method.TypeArguments[0],
method.TypeArguments[1]
);
return(DependencyRegistration.Factory(
scope,
dependencyType: method.TypeArguments[0],
factoryType: method.TypeArguments[1],
concreteType: concreteType
));
}
internal override DependencyRegistration GetRegistration(IMethodSymbol method, SeparatedSyntaxList <ArgumentSyntax> arguments, SemanticModel semanticModel)
{
if (arguments.Count != 1)
{
return(null);
}
ObjectScope scope;
if (!TryGetObjectScope(arguments[0], semanticModel, out scope))
{
return(null);
}
if (method.Name.Contains("Factory"))
{
ITypeSymbol concreteType = GetConstructedTypeOfIFactory(
semanticModel,
method.TypeArguments[0],
method.TypeArguments[1]
);
return(DependencyRegistration.Factory(
scope,
method.TypeArguments[1],
method.TypeArguments[2],
concreteType
));
}
else
{
return(DependencyRegistration.NonFactory(
scope,
method.TypeArguments[1],
method.TypeArguments[2]
));
}
}
internal override DependencyRegistration GetRegistration(IMethodSymbol method, SeparatedSyntaxList <ArgumentSyntax> arguments, SemanticModel semanticModel)
{
if (arguments.Count != 1)
{
return(null);
}
var concreteType = semanticModel.GetTypeInfo(arguments[0].Expression).Type;
var dependencyType = concreteType;
if (method.TypeArguments.Length == 1)
{
// if there's a type argument provided, use that for dependency type instead
dependencyType = method.TypeArguments[0];
}
if (concreteType.IsNullOrErrorType())
{
// concreteType can sometimes legitimately not resolve, like in this case:
// Register<IFoo>( null );
concreteType = dependencyType;
}
return(DependencyRegistration.Instance(ObjectScope.Singleton, dependencyType, concreteType));
}
internal override DependencyRegistration GetRegistration(IMethodSymbol method, SeparatedSyntaxList <ArgumentSyntax> arguments, SemanticModel semanticModel)
{
if (arguments.Count != 3)
{
return(null);
}
// This only handles the case where `typeof` is used inline.
// This sucks, but there are very few usages of this method (it's
// only used in open-generic types), so we don't care.
// r.Register( typeof(IFoo), typeof(Foo), ObjectScope.Singleton );
var dependencyTypeExpression = arguments[0].Expression as TypeOfExpressionSyntax;
if (dependencyTypeExpression == null)
{
return(null);
}
var dependencyType = semanticModel.GetSymbolInfo(dependencyTypeExpression.Type).Symbol as ITypeSymbol;
var concreteTypeExpression = arguments[1].Expression as TypeOfExpressionSyntax;
if (concreteTypeExpression == null)
{
return(null);
}
var concreteType = semanticModel.GetSymbolInfo(concreteTypeExpression.Type).Symbol as ITypeSymbol;
ObjectScope scope;
if (!TryGetObjectScope(arguments[2], semanticModel, out scope))
{
return(null);
}
return(DependencyRegistration.NonFactory(scope, dependencyType, concreteType));
}
