private void ProcessBehaviorField(IProject project, IFieldInfo field, IDeclaration declaration = null)
{
var behaviorType = field.FieldType.GetGenericArguments().FirstOrDefault();
var containingType = new ClrTypeName(field.DeclaringType);
if (_contexts.TryGetValue(containingType, out var context))
{
var behavior = _factory.GetOrCreateBehavior(
project,
context,
containingType,
field.ShortName,
field.IsIgnored());
OnUnitTestElement(behavior, declaration);
if (behaviorType != null && behaviorType.IsBehaviorContainer())
{
var specFields = behaviorType.GetFields()
.Where(x => x.IsSpecification());
foreach (var specField in specFields)
{
var specification = _factory.GetOrCreateBehaviorSpecification(
project,
behavior,
new ClrTypeName(specField.DeclaringType),
specField.ShortName,
specField.IsIgnored());
OnUnitTestElement(specification, declaration);
}
}
}
}
public static IClassDeclaration GetContractClassDeclaration(this IClassLikeDeclaration classLikeDeclaration)
{
Contract.Requires(classLikeDeclaration != null);
Contract.Requires(classLikeDeclaration.DeclaredElement != null);
var contractClassAttributeType = new ClrTypeName(typeof(ContractClassAttribute).FullName);
var contractClassAttributeInstance =
classLikeDeclaration.DeclaredElement.GetAttributeInstances(contractClassAttributeType, true)
.FirstOrDefault();
if (contractClassAttributeInstance == null)
{
return(null);
}
Contract.Assert(contractClassAttributeInstance.PositionParameterCount == 1);
return(contractClassAttributeInstance.PositionParameters()
.FirstOrDefault()
.With(x => x.TypeValue)
.With(x => x.GetScalarType())
.With(x => x.Resolve())
.With(x => x.DeclaredElement)
.With(x => x.GetDeclarations().FirstOrDefault())
.Return(x => x as IClassDeclaration));
}
public override IUnitTestElement Map(Test test)
{
using (ReadLockCookie.Create())
{
var assemblyPath = _project?.GetOutputFilePath(_targetFrameworkId);
var typeName = GetType(test);
var fieldName = GetField(test);
var subject = GetTraits(test, "Subject").FirstOrDefault();
var tags = GetTraits(test, "Tag");
var behaviorField = GetTraits(test, "BehaviorField").FirstOrDefault();
var behaviorType = GetTraits(test, "BehaviorType").FirstOrDefault();
var type = new ClrTypeName(typeName);
var context = _factory.GetOrCreateContext(_project, type, assemblyPath, subject, tags.ToArray(), false);
if (!string.IsNullOrEmpty(behaviorField) && !string.IsNullOrEmpty(behaviorType))
{
var behavior = _factory.GetOrCreateBehavior(_project, context, type, behaviorField, false);
return(_factory.GetOrCreateBehaviorSpecification(_project, behavior, new ClrTypeName(behaviorType), fieldName, false));
}
return(_factory.GetOrCreateContextSpecification(_project, context, type, fieldName, false));
}
}
private static ContractStatement CreateSpecialInvocationContractStatement(ICSharpStatement statement)
{
var method = statement.GetInvokedMethod();
if (method == null)
{
return(null);
}
var validatorAttribute = new ClrTypeName("System.Diagnostics.Contracts.ContractArgumentValidatorAttribute");
if (method.HasAttributeInstance(validatorAttribute, false))
{
return(ContractValidatorStatement.TryCreate(statement, method));
}
var abbreviationAttribute = new ClrTypeName("System.Diagnostics.Contracts.ContractAbbreviatorAttribute");
if (method.HasAttributeInstance(abbreviationAttribute, false))
{
return(ContractAbbreviationStatement.TryCreate(statement, method));
}
return(null);
}
private IClrTypeName GetInternedClrTypeName(string typeName)
{
if (!myTypeNames.TryGetValue(typeName, out var clrTypeName))
{
clrTypeName = new ClrTypeName(typeName);
myTypeNames.Add(typeName, clrTypeName);
}
return(clrTypeName);
}
private IClrTypeName GetClrTypeName(string typeName)
{
IClrTypeName clrTypeName;
if (!myTypeNames.TryGetValue(typeName, out clrTypeName))
{
clrTypeName = new ClrTypeName(typeName);
myTypeNames.Add(typeName, clrTypeName);
}
return clrTypeName;
}
private IClrTypeName GetClrTypeName(string typeName)
{
IClrTypeName clrTypeName;
if (!myTypeNames.TryGetValue(typeName, out clrTypeName))
{
clrTypeName = new ClrTypeName(typeName);
myTypeNames.Add(typeName, clrTypeName);
}
return(clrTypeName);
}
public static bool HasAttribute(this IClassLikeDeclaration classLikeDeclaration, Type attributeType)
{
Contract.Requires(classLikeDeclaration != null);
Contract.Requires(classLikeDeclaration.DeclaredElement != null);
Contract.Requires(attributeType != null);
Contract.Requires(attributeType.IsAttribute());
var clrAttribute = new ClrTypeName(attributeType.FullName);
return classLikeDeclaration.DeclaredElement.HasAttributeInstance(
new ClrTypeName(attributeType.FullName), inherit: true);
}
public static bool HasAttribute(this IClassLikeDeclaration classLikeDeclaration, Type attributeType)
{
Contract.Requires(classLikeDeclaration != null);
Contract.Requires(classLikeDeclaration.DeclaredElement != null);
Contract.Requires(attributeType != null);
Contract.Requires(attributeType.IsAttribute());
var clrAttribute = new ClrTypeName(attributeType.FullName);
return(classLikeDeclaration.DeclaredElement.HasAttributeInstance(
new ClrTypeName(attributeType.FullName), inherit: true));
}
public void ContextWithNoSubjectPresentationIsValid()
{
With(() =>
{
var id = CreateId("id");
var type = new ClrTypeName("Namespace.Elements.my_class_name");
var element = new ContextElement(id, type, ServiceProvider, null, false);
Assert.That(element.GetPresentation(null, false), Is.EqualTo("my class name"));
});
}
public void SameTypeNamesCanBeAKey()
{
var name1 = new ClrTypeName("Namespace.Name1");
var name2 = new ClrTypeName("Namespace.Name1");
var dictionary = new Dictionary <ClrTypeName, int>();
dictionary[name1] = 1;
dictionary[name2] = 2;
Assert.That(dictionary.Count, Is.EqualTo(1));
Assert.That(name1, Is.EqualTo(name2));
}
public void DifferentTypeNamesAreUnique()
{
var name1 = new ClrTypeName("Namespace.Name1");
var name2 = new ClrTypeName("Namespace.Name2");
var dictionary = new Dictionary <ClrTypeName, int>();
dictionary[name1] = 1;
dictionary[name2] = 2;
Assert.That(dictionary.Count, Is.EqualTo(2));
Assert.That(name1, Is.Not.EqualTo(name2));
}
private void ProcessSpecificationField(IProject project, IFieldInfo field, IDeclaration declaration = null)
{
var containingType = new ClrTypeName(field.DeclaringType);
if (_contexts.TryGetValue(containingType, out var context))
{
var specification = _factory.GetOrCreateContextSpecification(
project,
context,
containingType,
field.ShortName,
field.IsIgnored());
OnUnitTestElement(specification, declaration);
}
}
private static ContractStatement CreateSpecialInvocationContractStatement(ICSharpStatement statement)
{
var method = statement.GetInvokedMethod();
if (method == null)
return null;
var validatorAttribute = new ClrTypeName("System.Diagnostics.Contracts.ContractArgumentValidatorAttribute");
if (method.HasAttributeInstance(validatorAttribute, false))
return ContractValidatorStatement.TryCreate(statement, method);
var abbreviationAttribute = new ClrTypeName("System.Diagnostics.Contracts.ContractAbbreviatorAttribute");
if (method.HasAttributeInstance(abbreviationAttribute, false))
return ContractAbbreviationStatement.TryCreate(statement, method);
return null;
}
public static IAttribute GetAttibuteOfCLRType(this IEnumerable<IAttribute> attributes, ClrTypeName clrTypeName)
{
return attributes.FirstOrDefault(a =>
{
var typeReference = a.TypeReference;
if (typeReference != null)
{
var typeElement =
typeReference.Resolve().DeclaredElement as ITypeElement;
if (typeElement != null && Equals(typeElement.GetClrName(), clrTypeName))
{
return true;
}
}
return false;
});
}
protected override void Run(IDllImportMethodDeclaration importMethod, ElementProblemAnalyzerData data, IHighlightingConsumer consumer)
{
var element = importMethod.MethodDeclaration;
var libraryName = importMethod.ImportedDll;
var factory = new LibraryFactory();
var library = factory.LoadLibrary(libraryName);
var export = library[element.NameIdentifier.Name];
if (export == null || export.Parameters.Count != element.ParameterDeclarations.Count)
{
return;
}
for (var i = 0; i < element.ParameterDeclarations.Count; i++ )
{
var parameter = element.ParameterDeclarations[i];
var knownParameter = export.Parameters[i];
var exportedType = new ClrTypeName(knownParameter.CLRType.FullName);
if (parameter.Type.IsInt() && exportedType.Equals(IntPtrClrType))
{
consumer.AddHighlighting(new DllImportInt32ForIntPtrHighlighting(parameter));
}
var marshalAs = parameter.Attributes.GetAttibuteOfCLRType(MarshalAsAttribute);
if (knownParameter.UnmanagedType.HasValue && marshalAs != null && marshalAs.ConstructorArgumentExpressions.Count == 1)
{
var argumentExpression = marshalAs.ConstructorArgumentExpressions[0];
if (!argumentExpression.IsConstantValue())
{
continue;
}
var shortType = argumentExpression.ConstantValue.IsShort();
UnmanagedType unmanagedType;
if (shortType)
{
unmanagedType = (UnmanagedType)(short)argumentExpression.ConstantValue.Value;
}
else
{
unmanagedType = (UnmanagedType)argumentExpression.ConstantValue.Value;
}
if (knownParameter.UnmanagedType.Value != unmanagedType)
{
consumer.AddHighlighting(new DllImportIncorrectParameterMarshalHighlighting(parameter, argumentExpression, knownParameter.UnmanagedType.Value));
}
}
}
}
public static bool Is([NotNull] this IType type, [NotNull] Type reflecationType)
{
if (reflecationType.IsArray && !type.IsArrayOf(reflecationType.GetElementType(), reflecationType.GetArrayRank()))
{
return(false);
}
if (!(type is IDeclaredType declaredType))
{
return(false);
}
Type[] genericArguments = reflecationType.GetGenericArguments();
if (genericArguments.Length == 0 || reflecationType.ContainsGenericParameters)
{
var clrTypeName = new ClrTypeName(reflecationType.FullName);
return(declaredType.GetClrName().Equals(clrTypeName));
}
using (IEnumerator <IType> underlyingTypesEnumerator = GetGenericUnderlyingTypes(type).GetEnumerator())
{
foreach (Type genericArgumentType in genericArguments)
{
if (!underlyingTypesEnumerator.MoveNext())
{
return(false);
}
if (!underlyingTypesEnumerator.Current.Is(genericArgumentType))
{
return(false);
}
}
if (underlyingTypesEnumerator.MoveNext())
{
return(false);
}
}
return(true);
}
public ITypeElement GetClassForSearch(IParametersOwner originalMethod, IType invokedType)
{
var containingType = originalMethod.GetContainingType();
if (containingType == null)
{
return(null);
}
if (!invokedType.IsGenericIQueryable() || !containingType.IsEnumerableClass())
{
return(null);
}
var queryableName = new ClrTypeName("System.Data.Entity.QueryableExtensions");
var queryableType = TypeFactory.CreateTypeByCLRName(queryableName, NullableAnnotation.Unknown, invokedType.Module);
var queryableTypeElement = queryableType.GetTypeElement();
return(queryableTypeElement);
}
private static ITypeElement GetClassForMethodSearch(IType invokedObjectType, [NotNull] IParametersOwner originalMethod, [NotNull] IPsiModule psiModule)
{
var containingType = originalMethod.GetContainingType();
if (containingType == null)
{
return(null);
}
if (!invokedObjectType.IsGenericIQueryable() || !IsEnumerable(containingType))
{
return(containingType);
}
var queryableName = new ClrTypeName("System.Data.Entity.QueryableExtensions");
var queryableType = TypeFactory.CreateTypeByCLRName(queryableName, psiModule);
var queryableTypeElement = queryableType.GetTypeElement();
return(queryableTypeElement);
}
private void ProcessContext(ITypeInfo type, IDeclaration declaration, bool isClear)
{
var name = new ClrTypeName(type.FullyQualifiedName);
var project = declaration.GetProject();
var assemblyPath = project?.GetOutputFilePath(_observer.TargetFrameworkId);
var context = _factory.GetOrCreateContext(
project,
name,
assemblyPath,
type.GetSubject(),
type.GetTags().ToArray(),
type.IsIgnored());
_contexts[name] = context;
if (isClear)
{
OnUnitTestElement(context, declaration);
}
}
public void Execute(ISolution solution, ITextControl textControl)
{
var jetPopupMenus = solution.GetPsiServices().GetComponent <JetPopupMenus>();
var cache = solution.GetComponent <SpecflowStepsDefinitionsCache>();
jetPopupMenus.ShowModal(JetPopupMenu.ShowWhen.AutoExecuteIfSingleEnabledItem,
(lifetime, menu) =>
{
menu.Caption.Value = WindowlessControlAutomation.Create("Where to create the step ?");
var availableSteps = cache.GetBindingTypes(_reference.GetElement().GetPsiModule());
var filesPerClasses = new OneToSetMap <string, SpecflowStepsDefinitionsCache.AvailableBindingClass>();
foreach (var availableBindingClass in availableSteps)
{
filesPerClasses.Add(availableBindingClass.ClassClrName, availableBindingClass);
}
menu.ItemKeys.AddRange(filesPerClasses);
menu.DescribeItem.Advise(lifetime, e =>
{
var(classClrFullName, _) = (KeyValuePair <string, ISet <SpecflowStepsDefinitionsCache.AvailableBindingClass> >)e.Key;
e.Descriptor.Icon = PsiSymbolsThemedIcons.Class.Id;
e.Descriptor.Style = MenuItemStyle.Enabled;
var clrTypeName = new ClrTypeName(classClrFullName);
e.Descriptor.Text = new RichText(clrTypeName.ShortName, DeclaredElementPresenterTextStyles.ParameterInfo.GetStyle(DeclaredElementPresentationPartKind.Type));
e.Descriptor.ShortcutText = clrTypeName.GetNamespaceName();
});
menu.ItemClicked.Advise(lifetime, key =>
{
var(_, availableBindingClasses) = (KeyValuePair <string, ISet <SpecflowStepsDefinitionsCache.AvailableBindingClass> >)key;
OpenFileSelectionModal(jetPopupMenus, textControl, availableBindingClasses, _reference.GetStepKind(), _reference.GetStepText());
});
menu.PopupWindowContextSource = textControl.PopupWindowContextFactory.ForCaret();
});
}
public static IClassDeclaration GetContractClassDeclaration(this IClassLikeDeclaration classLikeDeclaration)
{
Contract.Requires(classLikeDeclaration != null);
Contract.Requires(classLikeDeclaration.DeclaredElement != null);
var contractClassAttributeType = new ClrTypeName(typeof(ContractClassAttribute).FullName);
var contractClassAttributeInstance =
classLikeDeclaration.DeclaredElement.GetAttributeInstances(contractClassAttributeType, true)
.FirstOrDefault();
if (contractClassAttributeInstance == null)
return null;
Contract.Assert(contractClassAttributeInstance.PositionParameterCount == 1);
return contractClassAttributeInstance.PositionParameters()
.FirstOrDefault()
.With(x => x.TypeValue)
.With(x => x.GetScalarType())
.With(x => x.Resolve())
.With(x => x.DeclaredElement)
.With(x => x.GetDeclarations().FirstOrDefault())
.Return(x => x as IClassDeclaration);
}
/// <summary> /// Specifies a type closure /// </summary> /// <param name="openType">The name of the type over which to close</param> /// <param name="arguments">The arguments supplied to the type parameters</param> /// <returns></returns> public static ClrTypeClosure close(ClrTypeName openType, params (ClrTypeName argType, string argName)[] arguments)
public ClassTestElement(ITestIdentity identity, IList<Task> tasks)
: base(identity, tasks)
{
_testTypeName = new ClrTypeName(identity.Relative);
}
public ClassTestElement(ITestIdentity identity, IList <Task> tasks)
: base(identity, tasks)
{
_testTypeName = new ClrTypeName(identity.Relative);
}
private static ICollection<IClass> GetTypesNonCached([NotNull] IArgumentsOwner argumentsOwner)
{
argumentsOwner.AssertIsValid("argumentsOwner is invalid");
var invocationExpression = argumentsOwner as IInvocationExpression;
if (invocationExpression != null)
{
var referenceExpression = invocationExpression.InvokedExpression as IReferenceExpression;
if (referenceExpression != null)
{
var typeofExpression = referenceExpression.QualifierExpression as ITypeofExpression;
if (typeofExpression != null)
{
IType type = typeofExpression.ArgumentType;
IClass @class = type.GetClassType();
return new[] {@class};
}
var gettypeExpression = referenceExpression.QualifierExpression as IInvocationExpression;
if (gettypeExpression != null && gettypeExpression.Reference != null && gettypeExpression.Reference.GetName() == "GetType")
{
var method = gettypeExpression.Reference.Resolve().DeclaredElement as IMethod;
if (method != null)
{
var containingType = method.GetContainingType();
if (containingType != null)
{
var containingTypeName = containingType.GetClrName().FullName;
if (containingTypeName == "System.Object")
{
var typeDeclaration = gettypeExpression.GetContainingNode<ITypeDeclaration>();
if (typeDeclaration != null)
{
return new[] {typeDeclaration.DeclaredElement as IClass};
}
}
if (containingTypeName == "System.Type" && method.IsStatic)
{
if (gettypeExpression.Arguments.Count > 0)
{
var literalExpression = gettypeExpression.Arguments[0].Expression as ICSharpLiteralExpression;
if (literalExpression != null && literalExpression.IsConstantValue() && literalExpression.ConstantValue.IsString())
{
var typeName = new ClrTypeName((string) literalExpression.ConstantValue.Value);
var name = new DeclaredTypeFromCLRName(typeName, gettypeExpression.GetPsiModule(), gettypeExpression.GetResolveContext());
return new[] { name.GetTypeElement() as IClass };
}
}
}
}
}
}
}
}
return EmptyList<IClass>.InstanceList;
}
