static IEnumerable <AttributeValue> PositionParameters(this IAttributeInstance source)
{
for (int i = 0; i < source.PositionParameterCount; i++)
{
yield return(source.PositionParameter(i));
}
}
private static int? GetTagFromProtoMember(IAttributeInstance attribute)
{
var tagParameter = attribute.PositionParameter(0);
if (!tagParameter.IsConstant)
return null;
return Convert.ToInt32(tagParameter.ConstantValue.Value);
}
private static string AnonymousPropertyInitializerRetriever(IAttributeInstance attr)
{
return(attr.PositionParameters()
.Select(value => value.ConstantValue)
.Where(value => value.IsString()).SelectNotNull(value => value.Value as string)
.FirstOrDefault());
}
public CommonAttribute GetCommonAttribute(IAttributeInstance attributeInstance)
{
var type = GetCommonType(attributeInstance.GetAttributeType());
var positionalArguments = attributeInstance.PositionParameters().Select(GetPositionalArgument).WhereNotNull();
var namedArguments = attributeInstance.NamedParameters().Select(GetNamedArguments).WhereNotNull();
return new CommonAttribute(type, positionalArguments, namedArguments);
}
public CommonAttribute GetCommonAttribute(IAttributeInstance attributeInstance)
{
var type = GetCommonType(attributeInstance.GetAttributeType());
var positionalArguments = attributeInstance.PositionParameters().Select(GetPositionalArgument).WhereNotNull();
var namedArguments = attributeInstance.NamedParameters().Select(GetNamedArguments).WhereNotNull();
return(new CommonAttribute(type, positionalArguments, namedArguments));
}
private string TryGetAnnotationShortName([CanBeNull] IAttributeInstance attribute, AnnotationsDisplayKind showAnnotations)
{
if (attribute != null && showAnnotations != AnnotationsDisplayKind.None)
{
string shortName = attribute.GetClrName().ShortName;
if (IsDisplayedAnnotation(attribute, shortName, showAnnotations))
{
return(shortName.TrimFromEnd("Attribute"));
}
}
return(null);
}
private void GetStateAndAttributes(IList state, IList attributeRows, String indentation, IFlow flow)
{
// add the flow to the state
IEnumerator iter = flow.Children.GetEnumerator();
while (iter.MoveNext())
{
state.Add(iter.Current);
}
// add the flow-name to the attributeRows
System.Collections.IDictionary row = new System.Collections.Hashtable();
if (flow.IsRootFlow())
{
row["name"] = indentation + "rootflow <b>[</b>" + flow.Name + "<b>]</b>";
}
else
{
row["name"] = indentation + "subflow <b>[</b>" + flow.Name + "<b>]</b>";
}
row["value"] = "";
attributeRows.Add(row);
// add the flow-local attributes to the attributeRows
iter = flow.AttributeInstances.GetEnumerator();
while (iter.MoveNext())
{
IAttributeInstance attributeInstance = (IAttributeInstance)iter.Current;
row = new Hashtable();
log.Debug("adding attribute instance value " + attributeInstance.GetValue());
row["name"] = indentation + " +- <b>[</b>" +
attributeInstance.Attribute.Name + "<b>]</b>";
row["value"] = attributeInstance.GetValue();
attributeRows.Add(row);
}
// recursively descend to the children
iter = flow.Children.GetEnumerator();
while (iter.MoveNext())
{
GetStateAndAttributes(state, attributeRows, indentation + " | ", (IFlow)iter.Current);
}
IProcessInstance processInstance = flow.GetSubProcessInstance();
if (processInstance != null)
{
state.Add(processInstance.RootFlow);
GetStateAndAttributes(state, attributeRows, indentation + " | ", processInstance.RootFlow);
}
}
private static bool IsValidAttributeInstance([NotNull] IAttributeInstance instance)
{
if (instance.PositionParameterCount != 2)
{
return(false);
}
var categoryParam = instance.PositionParameter(0);
if (!categoryParam.IsConstant || !categoryParam.ConstantValue.IsString() || (string)categoryParam.ConstantValue.Value != "ReSharper")
{
return(false);
}
var idParam = instance.PositionParameter(1);
return(idParam.IsConstant && idParam.ConstantValue.IsString());
}
private void WriterAttributes(IFlow flow, StreamWriter xmlwriter)
{
//NHibernate.LazyInitializationException: Failed to lazily initialize a collection - no session
IEnumerator iter = flow.AttributeInstances.GetEnumerator();
while (iter.MoveNext())
{
IAttributeInstance attributeInstance = (IAttributeInstance)iter.Current;
xmlwriter.WriteLine(" <attribute type=\"AT_UDA_12_"+ attributeInstance.Attribute.Name + "\">" + attributeInstance.GetValue() + "</attribute>");
}
// recursively descend to the children
iter = flow.Children.GetEnumerator();
while (iter.MoveNext())
{
WriterAttributes((IFlow)iter.Current, xmlwriter);
}
}
private bool IsDisplayedAnnotation([CanBeNull] IAttributeInstance attribute, [CanBeNull] string shortName, AnnotationsDisplayKind showAnnotations)
{
if (attribute == null || shortName == null)
{
return(false);
}
switch (showAnnotations)
{
case AnnotationsDisplayKind.Nullness:
return(shortName == NullnessProvider.CanBeNullAttributeShortName ||
shortName == NullnessProvider.NotNullAttributeShortName);
case AnnotationsDisplayKind.All:
return(_codeAnnotationsConfiguration.IsAnnotationAttribute(attribute, shortName));
default:
return(false);
}
}
public void CheckDelegateActivity(String authenticatedActorId, Int64 flowId, String delegateActorId)
{
//only director can delegate an activity
IExecutionApplicationService executionComponent = (IExecutionApplicationService)serviceLocator.GetService(typeof(IExecutionApplicationService));
try
{
IFlow flow = executionComponent.GetFlow(flowId, new Relations("attributeInstances"));
IActor director = null;
ISet attributeInstances = flow.AttributeInstances;
for (IEnumerator iter = attributeInstances.GetEnumerator(); iter.MoveNext();)
{
IAttributeInstance attributeInstance = (IAttributeInstance)iter.Current;
if ("director".Equals(attributeInstance.Attribute.Name))
{
director = (IActor)attributeInstance.GetValue();
}
}
if (director.Id.Equals(authenticatedActorId) == false)
{
throw new AuthorizationException("Only director is allowed to delegate activity");
}
}
catch (AuthorizationException e)
{
throw e;
}
catch (System.Exception e)
{
log.Error("failed doing authorization : ", e);
throw new System.SystemException("failed doing authorization : " + e.Message);
}
finally
{
serviceLocator.Release(executionComponent);
}
}
private static string TryExtractProjectNameFromAssemblyMetadataAttribute([NotNull] IAttributeInstance attributeInstance)
{
const string testProjectKey = "ReSharperHelpers.TestProject";
if (attributeInstance.PositionParameterCount != 2)
{
return(null);
}
var key = attributeInstance.PositionParameter(0);
if (key.IsConstant && key.ConstantValue.IsString() && string.Equals((string)key.ConstantValue.Value, testProjectKey, StringComparison.Ordinal))
{
var value = attributeInstance.PositionParameter(1);
if (value.IsConstant && value.ConstantValue.IsString())
{
return((string)value.ConstantValue.Value);
}
}
return(null);
}
public override IList <IAttributeInstance> GetAttributeInstances(IClrTypeName clrName)
{
if (AttributeClassNames.IsEmpty())
{
return(EmptyList <IAttributeInstance> .Instance);
}
if (!((GetDeclaration() as IFSharpTypeDeclaration)?.GetFSharpSymbol() is FSharpEntity entity))
{
return(EmptyList <IAttributeInstance> .Instance);
}
var psiModule = GetPsiModule();
var entityAttrs = entity.Attributes;
var attrs = new IAttributeInstance[entityAttrs.Count];
for (var i = 0; i < attrs.Length; i++)
{
attrs[i] = new FSharpAttributeInstance(entityAttrs[i], psiModule);
}
return(attrs);
}
private bool IsAttributeInstanceValid(IAttributeInstance attrib)
{
return attrib.Constructor != null && attrib.AttributeType != null;
}
private IAttribute GetCSharpAttributeHack(IAttributeInstance attributeInstance)
{
if (attributeInstance.GetType().Name != "CSharpAttributeInstance")
return null;
if (CSharpAttributeInstanceMyAttributeField == null)
CSharpAttributeInstanceMyAttributeField = attributeInstance.GetType().GetField("myAttribute",
BindingFlags.Instance | BindingFlags.NonPublic);
if (CSharpAttributeInstanceMyAttributeField == null)
return null;
return (IAttribute) CSharpAttributeInstanceMyAttributeField.GetValue(attributeInstance);
}
private ConstantValue2 GetAttributeNamedParameterHack(IAttributeInstance attributeInstance, ITypeMember typeMember)
{
IAttribute attribute = GetCSharpAttributeHack(attributeInstance);
if (attribute != null)
{
foreach (IPropertyAssignmentNode propertyAssignmentNode in attribute.ToTreeNode().PropertyAssignments)
{
IPropertyAssignment propertyAssignment = propertyAssignmentNode;
if (propertyAssignment.Reference.Resolve().DeclaredElement == typeMember)
{
IType propertyType = ((ITypeOwner)typeMember).Type;
ICSharpExpression expression = propertyAssignment.Source;
return GetCSharpConstantValueHack(expression, propertyType);
}
}
return ConstantValue2.BAD_VALUE;
}
return attributeInstance.NamedParameter(typeMember);
}
private ConstantValue2 GetAttributePositionParameterHack(IAttributeInstance attributeInstance, int index)
{
IAttribute attribute = GetCSharpAttributeHack(attributeInstance);
if (attribute != null)
{
IList<ICSharpArgument> arguments = attribute.Arguments;
if (index >= arguments.Count)
return ConstantValue2.BAD_VALUE;
ICSharpExpression expression = arguments[index].Value;
IList<IParameter> parameters = attributeInstance.Constructor.Parameters;
int lastParameterIndex = parameters.Count - 1;
if (index >= lastParameterIndex && parameters[lastParameterIndex].IsParameterArray)
return GetCSharpConstantValueHack(expression, ((IArrayType)parameters[lastParameterIndex].Type).ElementType);
return GetCSharpConstantValueHack(arguments[index].Value, parameters[index].Type);
}
return attributeInstance.PositionParameter(index);
}
public static CommonAttribute ToCommon(this IAttributeInstance attributeInstance)
{
return(IntrospectionUtility.Instance.GetCommonAttribute(attributeInstance));
}
public static IAttributeInfo AsAttributeInfo(this IAttributeInstance attribute)
{
return(new PsiAttributeInfoAdapter(attribute));
}
public PsiAttributeInfoAdapter(IAttributeInstance attribute)
{
this.attribute = attribute;
}
public AttributeInstanceWrapper(IAttributeInstance attribute)
{
this.attribute = attribute;
}
private ConstantValue? GetAttributeNamedParameter(IAttributeInstance attributeHandle, ITypeMember memberHandle)
{
#if RESHARPER_31
ConstantValue2 rawValue = GetAttributeNamedParameterHack(attributeHandle, memberHandle);
return rawValue.IsBadValue() ? (ConstantValue?)null : ConvertConstantValue(rawValue.Value);
#else
AttributeValue rawValue = attributeHandle.NamedParameter(memberHandle);
return rawValue.IsBadValue ? (ConstantValue?) null : ConvertConstantValue(rawValue);
#endif
}
public static IDeclaredType GetAttributeType(this IAttributeInstance attribute)
{
return(attribute.AttributeType);
}
private ConstantValue? GetAttributePositionParameter(IAttributeInstance attributeHandle, int index)
{
#if RESHARPER_31
ConstantValue2 rawValue = GetAttributePositionParameterHack(attributeHandle, index);
return rawValue.IsBadValue() ? (ConstantValue?)null : ConvertConstantValue(rawValue.Value);
#else
AttributeValue rawValue = attributeHandle.PositionParameter(index);
return rawValue.IsBadValue ? (ConstantValue?) null : ConvertConstantValue(rawValue);
#endif
}
internal static IAttributeInfo AsAttributeInfo(this IAttributeInstance attribute)
{
return(new AttributeInstanceWrapper(attribute));
}
