<Uri>https://github.com/dotnet/roslyn</Uri>
<Sha>0cb0d5796b336c6a746e6d14c129f2e2b44f4f5e</Sha>
</Dependency>
- <Dependency Name="Microsoft.CodeAnalysis.Analyzers" Version="3.3.5-beta1.23270.2">
+ <Dependency Name="Microsoft.CodeAnalysis.Analyzers" Version="3.3.5-beta1.23275.7">
<Uri>https://github.com/dotnet/roslyn-analyzers</Uri>
- <Sha>c30ffa69aadaf557d5f8be198ec868f8fa364c3f</Sha>
+ <Sha>2b6ab8d727ce73a78bcbf026ac75ea8a7c804daf</Sha>
</Dependency>
- <Dependency Name="Microsoft.CodeAnalysis.NetAnalyzers" Version="8.0.0-preview.23270.2">
+ <Dependency Name="Microsoft.CodeAnalysis.NetAnalyzers" Version="8.0.0-preview.23275.7">
<Uri>https://github.com/dotnet/roslyn-analyzers</Uri>
- <Sha>c30ffa69aadaf557d5f8be198ec868f8fa364c3f</Sha>
+ <Sha>2b6ab8d727ce73a78bcbf026ac75ea8a7c804daf</Sha>
</Dependency>
<Dependency Name="Microsoft.DotNet.ApiCompat.Task" Version="8.0.100-preview.2.23107.1">
<Uri>https://github.com/dotnet/sdk</Uri>
</ItemGroup>
<PropertyGroup>
<!-- dotnet/roslyn-analyzers dependencies -->
- <MicrosoftCodeAnalysisAnalyzersVersion>3.3.5-beta1.23270.2</MicrosoftCodeAnalysisAnalyzersVersion>
- <MicrosoftCodeAnalysisNetAnalyzersVersion>8.0.0-preview.23270.2</MicrosoftCodeAnalysisNetAnalyzersVersion>
+ <MicrosoftCodeAnalysisAnalyzersVersion>3.3.5-beta1.23275.7</MicrosoftCodeAnalysisAnalyzersVersion>
+ <MicrosoftCodeAnalysisNetAnalyzersVersion>8.0.0-preview.23275.7</MicrosoftCodeAnalysisNetAnalyzersVersion>
<!-- dotnet/roslyn dependencies -->
<!--
These versions should not be used by any project that contributes to the design-time experience in VS, such as an analyzer, code-fix, or generator assembly.
}
// Check that a type is suitable for use in a custom attribute.
- private bool ValidateType(Type t)
+ private static bool ValidateType(Type t)
{
if (t.IsPrimitive)
{
// Wrap a custom attribute argument (or an element of an array-typed custom attribute argument) in a CustomAttributeTypeArgument structure
// for insertion into a CustomAttributeData value.
//
- protected CustomAttributeTypedArgument WrapInCustomAttributeTypedArgument(object? value, Type argumentType)
+ protected static CustomAttributeTypedArgument WrapInCustomAttributeTypedArgument(object? value, Type argumentType)
{
if (argumentType == typeof(object))
{
//
// Helper for jagged array constructors.
//
- private Array CreateJaggedArray(RuntimeTypeInfo arrayType, int[] lengths, int index)
+ private static Array CreateJaggedArray(RuntimeTypeInfo arrayType, int[] lengths, int index)
{
int length = lengths[index];
Array jaggedArray = ReflectionCoreExecution.ExecutionEnvironment.NewArray(arrayType.TypeHandle, length);
#region Private Helpers
- private bool TryGetTypeFromSimpleTypeSignature(ref NativeParser parser, NativeFormatModuleInfo moduleHandle, out RuntimeTypeHandle typeHandle)
+ private static bool TryGetTypeFromSimpleTypeSignature(ref NativeParser parser, NativeFormatModuleInfo moduleHandle, out RuntimeTypeHandle typeHandle)
{
uint data;
TypeSignatureKind kind = parser.GetTypeSignatureKind(out data);
}
}
- private bool CompareMethodSigs(NativeParser parser1, NativeFormatModuleInfo moduleHandle1, NativeParser parser2, NativeFormatModuleInfo moduleHandle2)
+ private static bool CompareMethodSigs(NativeParser parser1, NativeFormatModuleInfo moduleHandle1, NativeParser parser2, NativeFormatModuleInfo moduleHandle2)
{
MethodCallingConvention callingConvention1 = (MethodCallingConvention)parser1.GetUnsigned();
MethodCallingConvention callingConvention2 = (MethodCallingConvention)parser2.GetUnsigned();
return true;
}
- private bool CompareTypeSigs(ref NativeParser parser1, NativeFormatModuleInfo moduleHandle1, ref NativeParser parser2, NativeFormatModuleInfo moduleHandle2)
+ private static bool CompareTypeSigs(ref NativeParser parser1, NativeFormatModuleInfo moduleHandle1, ref NativeParser parser2, NativeFormatModuleInfo moduleHandle2)
{
// startOffset lets us backtrack to the TypeSignatureKind for external types since the TypeLoader
// expects to read it in.
/// <summary>
/// Metadata based computation of interfaces.
/// </summary>
- private DefType[] ComputeRuntimeInterfacesForNonInstantiatedMetadataType(MetadataType type)
+ private static DefType[] ComputeRuntimeInterfacesForNonInstantiatedMetadataType(MetadataType type)
{
DefType[] explicitInterfaces = type.ExplicitlyImplementedInterfaces;
DefType[] baseTypeInterfaces = (type.BaseType != null) ? (type.BaseType.RuntimeInterfaces) : Array.Empty<DefType>();
/// <summary>
/// Add an interface and its required interfaces to the interfacesArray
/// </summary>
- private void BuildPostOrderInterfaceList(DefType iface, ref ArrayBuilder<DefType> interfacesArray)
+ private static void BuildPostOrderInterfaceList(DefType iface, ref ArrayBuilder<DefType> interfacesArray)
{
if (interfacesArray.Contains(iface))
return;
//
// Gather the local details in a scope and then recurse to child scopes
//
- private void ProbeScopeForLocals(List<ILLocalVariable> variables, ISymUnmanagedScope scope)
+ private static void ProbeScopeForLocals(List<ILLocalVariable> variables, ISymUnmanagedScope scope)
{
int localCount;
ThrowExceptionForHR(scope.GetLocalCount(out localCount));
/// Do not adjust vtable index for generic dictionary slot
/// The vtable index is only actually valid if whichEntries is set to VTableEntriesToProcess.AllInVTable
/// </summary>
- private void ProcessVTableEntriesForCallingConventionSignatureGeneration(NodeFactory factory, VTableEntriesToProcess whichEntries, ref int currentVTableIndex, Action<int, bool, MethodDesc, MethodDesc> operation, TypeDesc implType, TypeDesc declType, TypeDesc templateType)
+ private static void ProcessVTableEntriesForCallingConventionSignatureGeneration(NodeFactory factory, VTableEntriesToProcess whichEntries, ref int currentVTableIndex, Action<int, bool, MethodDesc, MethodDesc> operation, TypeDesc implType, TypeDesc declType, TypeDesc templateType)
{
if (implType.IsInterface)
return;
/// <remarks>
/// "alreadySeen" is actually a stack but we use a List<> because Stack<> doesn't support indexing.
/// </remarks>
- private void FindCyclesWorker(Edge edge, List<Edge> alreadySeen, ref int operationCount, Stopwatch previousAlgorithmTimeoutWatch)
+ private static void FindCyclesWorker(Edge edge, List<Edge> alreadySeen, ref int operationCount, Stopwatch previousAlgorithmTimeoutWatch)
{
Vertex vertex = edge.Destination;
/// This method also records bindings for any generic instances it finds inside the tree expression.
/// Sometimes, this side-effect is all that's wanted - in such cases, invoke this method with a default collector.
/// </summary>
- private void ForEachEmbeddedGenericFormal(TypeDesc typeExpression, Instantiation typeContext, Instantiation methodContext, ref EmbeddingStateList collector)
+ private static void ForEachEmbeddedGenericFormal(TypeDesc typeExpression, Instantiation typeContext, Instantiation methodContext, ref EmbeddingStateList collector)
{
ForEachEmbeddedGenericFormalWorker(typeExpression, typeContext, methodContext, ref collector, depth: 0);
}
- private void ForEachEmbeddedGenericFormalWorker(TypeDesc type, Instantiation typeContext, Instantiation methodContext, ref EmbeddingStateList collector, int depth)
+ private static void ForEachEmbeddedGenericFormalWorker(TypeDesc type, Instantiation typeContext, Instantiation methodContext, ref EmbeddingStateList collector, int depth)
{
switch (type.Category)
{
// We will try VT_DISPATCH and then call GetNativeVariantForObject.
private const VarEnum VT_DEFAULT = VarEnum.VT_RECORD;
- private VarEnum GetComType(ref Type argumentType)
+ private static VarEnum GetComType(ref Type argumentType)
{
if (argumentType == typeof(Missing))
{
/// Get the COM Variant type that argument should be marshaled as for a call to COM
/// </summary>
[RequiresUnreferencedCode(Binder.TrimmerWarning)]
- private VariantBuilder GetVariantBuilder(Type argumentType)
+ private static VariantBuilder GetVariantBuilder(Type argumentType)
{
//argumentType is coming from MarshalType, null means the dynamic object holds
//a null value and not byref
OutputType(typeRef);
}
- private string GetArrayPostfix(CodeTypeReference typeRef)
+ private static string GetArrayPostfix(CodeTypeReference typeRef)
{
string s = "";
if (typeRef.ArrayElementType != null)
return section;
}
- private ConfigXmlReader FindSectionRecursive(string[] keys, int iKey, XmlUtil xmlUtil, ref int lineNumber)
+ private static ConfigXmlReader FindSectionRecursive(string[] keys, int iKey, XmlUtil xmlUtil, ref int lineNumber)
{
string name = keys[iKey];
ConfigXmlReader section = null;
}
// Force all sections and section groups to be instantiated.
- private void ForceGroupsRecursive(ConfigurationSectionGroup group)
+ private static void ForceGroupsRecursive(ConfigurationSectionGroup group)
{
foreach (ConfigurationSection configSection in group.Sections)
{
}
}
- private bool CopyConfigDeclarationsRecursive(
+ private static bool CopyConfigDeclarationsRecursive(
SectionUpdates declarationUpdates, XmlUtil xmlUtil, XmlUtilWriter utilWriter, string group,
int parentLinePosition, int parentIndent)
{
}
// SDUB: may be better to rewrite this as nonrecursive?
- internal DataTable? FindTable(DataTable? baseTable, PropertyDescriptor[] props, int propStart)
+ internal static DataTable? FindTable(DataTable? baseTable, PropertyDescriptor[] props, int propStart)
{
if (props.Length < propStart + 1)
{
return targetTable;
}
- private DataTable CloneHierarchy(DataTable sourceTable, DataSet ds, Hashtable? visitedMap)
+ private static DataTable CloneHierarchy(DataTable sourceTable, DataSet ds, Hashtable? visitedMap)
{
visitedMap ??= new Hashtable();
if (visitedMap.Contains(sourceTable))
WriteXmlSchema(w, writeHierarchy);
}
- private bool CheckForClosureOnExpressions(DataTable dt, bool writeHierarchy)
+ private static bool CheckForClosureOnExpressions(DataTable dt, bool writeHierarchy)
{
List<DataTable> tableList = new List<DataTable>();
tableList.Add(dt);
}
}
- private void CreateTableList(DataTable currentTable, List<DataTable> tableList)
+ private static void CreateTableList(DataTable currentTable, List<DataTable> tableList)
{
foreach (DataRelation r in currentTable.ChildRelations)
{
DataSet? dataSet = _table.DataSet;
if (dataSet != null)
{
- DataTable? foundTable = dataSet.FindTable(_table, listAccessors, 0);
+ DataTable? foundTable = DataSet.FindTable(_table, listAccessors, 0);
if (foundTable != null)
{
return foundTable.TableName;
return new PropertyDescriptorCollection(null);
}
- DataTable? foundTable = dataSet.FindTable(_table, listAccessors, 0);
+ DataTable? foundTable = DataSet.FindTable(_table, listAccessors, 0);
if (foundTable != null)
{
return foundTable.GetPropertyDescriptorCollection();
}
else
{
- DataTable? table = dataSet.FindTable(null, listAccessors, 0);
+ DataTable? table = DataSet.FindTable(null, listAccessors, 0);
if (table != null)
{
return table.TableName;
}
else
{
- DataTable? table = dataSet.FindTable(null, listAccessors, 0);
+ DataTable? table = DataSet.FindTable(null, listAccessors, 0);
if (table != null)
{
return table.GetPropertyDescriptorCollection();
}
- private bool IsOperatorIn(ExpressionNode? enode)
+ private static bool IsOperatorIn(ExpressionNode? enode)
{
BinaryNode? bnode = (enode as BinaryNode);
if (null != bnode)
}
}
- internal XmlSchemaObjectCollection? GetParticleItems(XmlSchemaParticle? pt)
+ internal static XmlSchemaObjectCollection? GetParticleItems(XmlSchemaParticle? pt)
{
if (pt is XmlSchemaSequence)
return ((XmlSchemaSequence)pt).Items;
return m;
}
- private ReadOnlyCollection<Expression> FixupQuotedArgs(MethodInfo mi, ReadOnlyCollection<Expression> argList)
+ private static ReadOnlyCollection<Expression> FixupQuotedArgs(MethodInfo mi, ReadOnlyCollection<Expression> argList)
{
ParameterInfo[] pis = mi.GetParameters();
if (pis.Length > 0)
return argList;
}
- private Expression FixupQuotedExpression(Type type, Expression expression)
+ private static Expression FixupQuotedExpression(Type type, Expression expression)
{
Expression expr = expression;
while (true)
}
}
- private bool TryPopulateNullabilityInfo(NullabilityInfo nullability, NullableAttributeStateParser parser, ref int index)
+ private static bool TryPopulateNullabilityInfo(NullabilityInfo nullability, NullableAttributeStateParser parser, ref int index)
{
bool isValueType = IsValueTypeOrValueTypeByRef(nullability.Type);
if (!isValueType)
_ilg.Load(localArray);
}
- private int SetRequiredElements(ClassDataContract contract, byte[] requiredElements)
+ private static int SetRequiredElements(ClassDataContract contract, byte[] requiredElements)
{
int memberCount = (contract.BaseClassContract == null) ? 0 :
SetRequiredElements(contract.BaseClassContract, requiredElements);
return true;
}
- private void InvokeOnSerializing(object obj, XmlObjectSerializerWriteContext context, ClassDataContract classContract)
+ private static void InvokeOnSerializing(object obj, XmlObjectSerializerWriteContext context, ClassDataContract classContract)
{
if (classContract.BaseClassContract != null)
InvokeOnSerializing(obj, context, classContract.BaseClassContract);
}
}
- private void InvokeOnSerialized(object obj, XmlObjectSerializerWriteContext context, ClassDataContract classContract)
+ private static void InvokeOnSerialized(object obj, XmlObjectSerializerWriteContext context, ClassDataContract classContract)
{
if (classContract.BaseClassContract != null)
InvokeOnSerialized(obj, context, classContract.BaseClassContract);
return false;
}
- protected int ReflectionGetMembers(ClassDataContract classContract, DataMember[] members)
+ protected static int ReflectionGetMembers(ClassDataContract classContract, DataMember[] members)
{
int memberCount = (classContract.BaseClassContract == null) ? 0 : ReflectionGetMembers(classContract.BaseClassContract, members);
int childElementIndex = memberCount;
return context.InternalDeserialize(xmlReader, DataContract.GetId(type.TypeHandle), type.TypeHandle, name, ns);
}
- private void InvokeOnDeserializing(XmlObjectSerializerReadContext context, ClassDataContract classContract, object obj)
+ private static void InvokeOnDeserializing(XmlObjectSerializerReadContext context, ClassDataContract classContract, object obj)
{
if (classContract.BaseClassContract != null)
InvokeOnDeserializing(context, classContract.BaseClassContract, obj);
}
}
- private void InvokeOnDeserialized(XmlObjectSerializerReadContext context, ClassDataContract classContract, object obj)
+ private static void InvokeOnDeserialized(XmlObjectSerializerReadContext context, ClassDataContract classContract, object obj)
{
if (classContract.BaseClassContract != null)
InvokeOnDeserialized(context, classContract.BaseClassContract, obj);
return collectionContract.ItemContract.ReadXmlValue(xmlReader, context);
}
- private bool[] GetRequiredMembers(ClassDataContract contract, out int firstRequiredMember)
+ private static bool[] GetRequiredMembers(ClassDataContract contract, out int firstRequiredMember)
{
int memberCount = contract.MemberNames!.Length;
bool[] requiredMembers = new bool[memberCount];
return requiredMembers;
}
- private int GetRequiredMembers(ClassDataContract contract, bool[] requiredMembers)
+ private static int GetRequiredMembers(ClassDataContract contract, bool[] requiredMembers)
{
int memberCount = (contract.BaseClassContract == null) ? 0 : GetRequiredMembers(contract.BaseClassContract, requiredMembers);
List<DataMember> members = contract.Members!;
}
}
- private void ImportGenericInfo(XmlSchemaType type, DataContract dataContract)
+ private static void ImportGenericInfo(XmlSchemaType type, DataContract dataContract)
{
if (type.Annotation == null || type.Annotation.Items == null)
return;
}
}
- private GenericInfo ImportGenericInfo(XmlElement typeElement, XmlSchemaType type)
+ private static GenericInfo ImportGenericInfo(XmlElement typeElement, XmlSchemaType type)
{
string? name = typeElement.Attributes.GetNamedItem(Globals.GenericNameAttribute)?.Value;
if (name == null)
return memberCount;
}
- private bool[] GetRequiredMembers(ClassDataContract contract, out int firstRequiredMember)
+ private static bool[] GetRequiredMembers(ClassDataContract contract, out int firstRequiredMember)
{
int memberCount = contract.MemberNames!.Length;
bool[] requiredMembers = new bool[memberCount];
return requiredMembers;
}
- private int GetRequiredMembers(ClassDataContract contract, bool[] requiredMembers)
+ private static int GetRequiredMembers(ClassDataContract contract, bool[] requiredMembers)
{
int memberCount = (contract.BaseClassContract == null) ? 0 : GetRequiredMembers(contract.BaseClassContract, requiredMembers);
List<DataMember> members = contract.Members!;
return XmlCharType.IsOnlyWhitespace(data);
}
- internal bool DecideXPNodeTypeForTextNodes(XmlNode node, ref XPathNodeType xnt)
+ internal static bool DecideXPNodeTypeForTextNodes(XmlNode node, ref XPathNodeType xnt)
{
//returns true - if all siblings of the node are processed else returns false.
//The reference XPathNodeType argument being passed in is the watermark that
get
{
XPathNodeType xnt = XPathNodeType.SignificantWhitespace;
- DecideXPNodeTypeForTextNodes(this, ref xnt);
+ XmlCharacterData.DecideXPNodeTypeForTextNodes(this, ref xnt);
return xnt;
}
}
XmlSchema schemaToUpdate = redefineEntry.schemaToUpdate;
ArrayList includesOfRedefine = new ArrayList();
- GetIncludedSet(originalSchema, includesOfRedefine);
+ Preprocessor.GetIncludedSet(originalSchema, includesOfRedefine);
string targetNS = schemaToUpdate.TargetNamespace ?? string.Empty;
XmlSchemaObjectCollection items = redefine.Items;
}
}
- private void GetIncludedSet(XmlSchema schema, ArrayList includesList)
+ private static void GetIncludedSet(XmlSchema schema, ArrayList includesList)
{
if (includesList.Contains(schema))
{
return -1;
}
- private bool IsParticleEmptiable(XmlSchemaParticle particle)
+ private static bool IsParticleEmptiable(XmlSchemaParticle particle)
{
decimal minOccurs;
CalculateEffectiveTotalRange(particle, out minOccurs, out _);
return minOccurs == decimal.Zero;
}
- private void CalculateEffectiveTotalRange(XmlSchemaParticle particle, out decimal minOccurs, out decimal maxOccurs)
+ private static void CalculateEffectiveTotalRange(XmlSchemaParticle particle, out decimal minOccurs, out decimal maxOccurs)
{
if (particle is XmlSchemaElement || particle is XmlSchemaAny)
{
}
#if DEBUG
- private string DumpContentModel(XmlSchemaParticle particle)
+ private static string DumpContentModel(XmlSchemaParticle particle)
{
StringBuilder sb = new StringBuilder();
DumpContentModelTo(sb, particle);
return sb.ToString();
}
- private void DumpContentModelTo(StringBuilder sb, XmlSchemaParticle particle)
+ private static void DumpContentModelTo(StringBuilder sb, XmlSchemaParticle particle)
{
if (particle is XmlSchemaElement)
{
}
#endif
- private void BuildParticleContentModel(ParticleContentValidator contentValidator, XmlSchemaParticle particle)
+ private static void BuildParticleContentModel(ParticleContentValidator contentValidator, XmlSchemaParticle particle)
{
if (particle is XmlSchemaElement element)
{
_schema = schema;
_xmlns = NameTable.Add("xmlns");
- Cleanup(schema);
+ SchemaCollectionPreprocessor.Cleanup(schema);
if (loadExternals && _xmlResolver != null)
{
_schemaLocations = new Hashtable(); //new Dictionary<Uri, Uri>();
return !HasErrors;
}
- private void Cleanup(XmlSchema schema)
+ private static void Cleanup(XmlSchema schema)
{
if (schema.IsProcessing)
{
return !HasErrors;
}
- private void CleanupAttribute(XmlSchemaAttribute attribute)
+ private static void CleanupAttribute(XmlSchemaAttribute attribute)
{
if (attribute.SchemaType != null)
{
attribute.AttDef = null;
}
- private void CleanupAttributeGroup(XmlSchemaAttributeGroup attributeGroup)
+ private static void CleanupAttributeGroup(XmlSchemaAttributeGroup attributeGroup)
{
CleanupAttributes(attributeGroup.Attributes);
attributeGroup.AttributeUses.Clear();
}
}
- private void CleanupSimpleType(XmlSchemaSimpleType simpleType)
+ private static void CleanupSimpleType(XmlSchemaSimpleType simpleType)
{
if (simpleType == XmlSchemaType.GetBuiltInSimpleType(simpleType.TypeCode))
{ //If it is a built-in simple type dont clean up
element.IsLocalTypeDerivationChecked = false; //clear Local element type derivation check
}
- private void CleanupAttributes(XmlSchemaObjectCollection attributes)
+ private static void CleanupAttributes(XmlSchemaObjectCollection attributes)
{
for (int i = 0; i < attributes.Count; ++i)
{
return -1;
}
- private bool IsParticleEmptiable(XmlSchemaParticle particle)
+ private static bool IsParticleEmptiable(XmlSchemaParticle particle)
{
decimal minOccurs;
CalculateEffectiveTotalRange(particle, out minOccurs, out _);
return minOccurs == decimal.Zero;
}
- private void CalculateEffectiveTotalRange(XmlSchemaParticle particle, out decimal minOccurs, out decimal maxOccurs)
+ private static void CalculateEffectiveTotalRange(XmlSchemaParticle particle, out decimal minOccurs, out decimal maxOccurs)
{
XmlSchemaChoice? choice = particle as XmlSchemaChoice;
}
}
- private bool BuildParticleContentModel(ParticleContentValidator contentValidator, XmlSchemaParticle particle)
+ private static bool BuildParticleContentModel(ParticleContentValidator contentValidator, XmlSchemaParticle particle)
{
bool hasWildCard = false;
if (particle is XmlSchemaElement element)
internal ArrayList ImportedNamespaces => _importedNamespaces ??= new ArrayList();
- internal void GetExternalSchemasList(IList extList, XmlSchema schema)
+ internal static void GetExternalSchemasList(IList extList, XmlSchema schema)
{
Debug.Assert(extList != null && schema != null);
if (extList.Contains(schema))
{
//Remove From ChameleonSchemas and schemaLocations cache
List<XmlSchema> reprocessList = new List<XmlSchema>();
- schema.GetExternalSchemasList(reprocessList, schema);
+ XmlSchema.GetExternalSchemasList(reprocessList, schema);
for (int i = 0; i < reprocessList.Count; ++i)
{ //Remove schema from schemaLocations & chameleonSchemas tables
if (reprocessList[i].BaseUri != null && reprocessList[i].BaseUri!.OriginalString.Length != 0)
{
foreach (Type t in scope.Types)
{
- compiler.AddImport(t, importedTypes);
+ Compiler.AddImport(t, importedTypes);
Assembly a = t.Assembly;
string name = a.FullName!;
if (assemblies[name] != null)
for (int i = 0; i < types.Length; i++)
{
- compiler.AddImport(types[i], importedTypes);
+ Compiler.AddImport(types[i], importedTypes);
}
var writer = new IndentedWriter(compiler.Source, false);
// SxS: This method does not take any resource name and does not expose any resources to the caller.
// It's OK to suppress the SxS warning.
[RequiresUnreferencedCode("Reflects against input Type DeclaringType")]
- internal void AddImport(Type? type, Hashtable types)
+ internal static void AddImport(Type? type, Hashtable types)
{
if (type == null)
return;
return model;
}
- private void CheckSupportedMember(TypeDesc? typeDesc, MemberInfo member, Type type)
+ private static void CheckSupportedMember(TypeDesc? typeDesc, MemberInfo member, Type type)
{
if (typeDesc == null)
return;
/// Returns true if the specified QilExpression node type is *guaranteed* to cache its results in an XmlQuerySequence,
/// where items in the cache are stored using the default storage type.
/// </summary>
- private bool CachesResult(QilNode nd)
+ private static bool CachesResult(QilNode nd)
{
OptimizerPatterns patt;
}
}
- private void FillModeFlags(Dictionary<QilName, XslFlags> parentModeFlags, Stylesheet sheet)
+ private static void FillModeFlags(Dictionary<QilName, XslFlags> parentModeFlags, Stylesheet sheet)
{
// Recursion: Process all imports to calculate ModeFlags for apply-import in this sheet
foreach (Stylesheet import in sheet.Imports!)
}
[Intrinsic]
+#pragma warning disable CA1822 // Mark members as static
internal int GetElementSize() => GetElementSize();
+#pragma warning restore
[MethodImpl(MethodImplOptions.InternalCall)]
private static extern CorElementType GetCorElementTypeOfElementTypeInternal(ObjectHandleOnStack arr);
return commands;
}
- private void AddNestedCommands(List<KeyValuePair<string, Command>> commands, string outer, CommandSet value)
+ private static void AddNestedCommands(List<KeyValuePair<string, Command>> commands, string outer, CommandSet value)
{
foreach (var v in value)
{
projects / platform / upstream / dotnet / runtime.git / commitdiff