public IConversionExpressionWithValue Convert(IConversionExpression expression)
{
if (expression is ImperialLengthExpression)
{
var tempExpression = (ImperialLengthExpression)expression;
return(new MetricLengthExpression {
Value = tempExpression.Value * (decimal)0.3048
});
}
else if (expression is ImperialAreaExpression)
{
var tempExpression = (ImperialAreaExpression)expression;
return(new MetricAreaExpression {
Value = tempExpression.Value * (decimal)0.0929
});
}
else if (expression is ImperialMassExpression)
{
var tempExpression = (ImperialMassExpression)expression;
return(new MetricMassExpression {
Value = tempExpression.Value * (decimal)453.59237
});
}
else if (expression is ImperialVolumeExpression)
{
var tempExpression = (ImperialVolumeExpression)expression;
return(new MetricVolumeExpression {
Value = tempExpression.Value * (decimal)0.0284130625
});
}
else
{
throw new InvalidExpressionException();
}
}
public override void VisitSimpleLambdaExpression(SimpleLambdaExpressionSyntax node)
{
SymbolInfo symInfo = m_Model.GetSymbolInfo(node);
var sym = symInfo.Symbol as IMethodSymbol;
if (null != sym && sym.Parameters.Length == 1)
{
var param = sym.Parameters[0];
CodeBuilder.AppendFormat("(function({0}) return ", param.Name);
IConversionExpression opd = null;
var oper = m_Model.GetOperation(node) as ILambdaExpression;
if (null != oper && oper.Body.Statements.Length == 1)
{
var iret = oper.Body.Statements[0] as IReturnStatement;
if (null != iret)
{
opd = iret.ReturnedValue as IConversionExpression;
}
}
var exp = node.Body as ExpressionSyntax;
OutputExpressionSyntax(exp, opd);
CodeBuilder.Append("; end)");
}
else
{
ReportIllegalSymbol(node, symInfo);
}
}
public override void VisitConversionExpression(IConversionExpression operation)
{
var usesOperatorMethod = operation.UsesOperatorMethod;
var operatorMethod = operation.OperatorMethod;
var conversion = operation.Conversion;
var isExplicitInCode = operation.IsExplicitInCode;
var isChecked = operation.IsChecked;
var isTryCast = operation.IsTryCast;
switch (operation.Language)
{
case LanguageNames.CSharp:
CSharp.Conversion csharpConversion = CSharp.CSharpExtensions.GetConversion(operation);
break;
case LanguageNames.VisualBasic:
VisualBasic.Conversion visualBasicConversion = VisualBasic.VisualBasicExtensions.GetConversion(operation);
break;
default:
Debug.Fail($"Language {operation.Language} is unknown!");
break;
}
base.VisitConversionExpression(operation);
}
public sealed override void Initialize(AnalysisContext context)
{
context.RegisterOperationAction(
(operationContext) =>
{
IOperation operation = operationContext.Operation;
if (operation.Kind == OperationKind.ConversionExpression)
{
IConversionExpression conversion = (IConversionExpression)operation;
if (conversion.Type.IsReferenceType &&
conversion.Operand.Type != null &&
conversion.Operand.Type.IsValueType &&
conversion.OperatorMethod == null)
{
Report(operationContext, conversion.Syntax);
}
}
// Calls to instance methods of value types don’t have conversions.
if (operation.Kind == OperationKind.InvocationExpression)
{
IInvocationExpression invocation = (IInvocationExpression)operation;
if (invocation.Instance != null &&
invocation.Instance.Type.IsValueType &&
invocation.TargetMethod.ContainingType.IsReferenceType)
{
Report(operationContext, invocation.Instance.Syntax);
}
}
},
OperationKind.ConversionExpression,
OperationKind.InvocationExpression);
}
private void AnalyzeXmlResolverPropertyAssignmentForXmlDocument(OperationAnalysisContext context, ISymbol assignedSymbol, IAssignmentExpression expression)
{
bool isSecureResolver = false;
IConversionExpression conv = expression.Value as IConversionExpression;
if (SecurityDiagnosticHelpers.IsXmlSecureResolverType(conv.Operand.Type, _xmlTypes))
{
isSecureResolver = true;
}
else if (conv != null && SecurityDiagnosticHelpers.IsExpressionEqualsNull(conv.Operand))
{
isSecureResolver = true;
}
else // Assigning XmlDocument's XmlResolver to an insecure value
{
Diagnostic diag = Diagnostic.Create(
RuleDoNotUseInsecureDtdProcessing,
context.Operation.Syntax.GetLocation(),
SecurityDiagnosticHelpers.GetLocalizableResourceString(
nameof(DesktopAnalyzersResources.XmlDocumentWithNoSecureResolverMessage)
)
);
context.ReportDiagnostic(diag);
}
if (_xmlDocumentEnvironments.ContainsKey(assignedSymbol))
{
XmlDocumentEnvironment xmlDocumentEnv = _xmlDocumentEnvironments[assignedSymbol];
xmlDocumentEnv.IsXmlResolverSet = true;
xmlDocumentEnv.IsSecureResolver = isSecureResolver;
}
}
public override void VisitForStatement(ForStatementSyntax node)
{
ContinueInfo ci = new ContinueInfo();
ci.Init(node.Statement);
m_ContinueInfoStack.Push(ci);
if (null != node.Declaration)
{
VisitVariableDeclaration(node.Declaration);
}
CodeBuilder.AppendFormat("{0}while ", GetIndentString());
if (null != node.Condition)
{
var oper = m_Model.GetOperation(node) as IForLoopStatement;
IConversionExpression opd = null;
if (null != oper)
{
opd = oper.Condition as IConversionExpression;
}
OutputExpressionSyntax(node.Condition, opd);
}
else
{
CodeBuilder.AppendLine("true");
}
CodeBuilder.AppendLine(" do");
if (ci.HaveContinue)
{
if (ci.HaveBreak)
{
CodeBuilder.AppendFormat("{0}local {1} = false", GetIndentString(), ci.BreakFlagVarName);
CodeBuilder.AppendLine();
}
CodeBuilder.AppendFormat("{0}repeat", GetIndentString());
CodeBuilder.AppendLine();
}
++m_Indent;
node.Statement.Accept(this);
--m_Indent;
if (ci.HaveContinue)
{
CodeBuilder.AppendFormat("{0}until true;", GetIndentString());
CodeBuilder.AppendLine();
if (ci.HaveBreak)
{
CodeBuilder.AppendFormat("{0}if {1} then break; end;", GetIndentString(), ci.BreakFlagVarName);
CodeBuilder.AppendLine();
}
}
foreach (var exp in node.Incrementors)
{
CodeBuilder.AppendFormat("{0}", GetIndentString());
VisitToplevelExpression(exp, ";");
}
CodeBuilder.AppendFormat("{0}end;", GetIndentString());
CodeBuilder.AppendLine();
m_ContinueInfoStack.Pop();
}
public override void VisitIfStatement(IfStatementSyntax node)
{
CodeBuilder.AppendFormat("{0}if ", GetIndentString());
var oper = m_Model.GetOperation(node) as IIfStatement;
IConversionExpression opd = null;
if (null != oper)
{
opd = oper.Condition as IConversionExpression;
}
OutputExpressionSyntax(node.Condition, opd);
CodeBuilder.AppendLine(" then");
++m_Indent;
node.Statement.Accept(this);
--m_Indent;
if (null != node.Else)
{
VisitElseClause(node.Else);
}
else
{
CodeBuilder.AppendFormat("{0}end;", GetIndentString());
CodeBuilder.AppendLine();
}
}
public IConversionExpressionWithValue Convert(IConversionExpression expression)
{
if (expression is MetricLengthExpression)
{
var tempExpression = (MetricLengthExpression)expression;
return(new ImperialLengthExpression {
Value = tempExpression.Value * (decimal)3.280839895
});
}
else if (expression is MetricAreaExpression)
{
var tempExpression = (MetricAreaExpression)expression;
return(new ImperialAreaExpression {
Value = tempExpression.Value * (decimal)10.76391041671
});
}
else if (expression is MetricMassExpression)
{
var tempExpression = (MetricMassExpression)expression;
return(new ImperialMassExpression {
Value = tempExpression.Value * (decimal)0.00220462262185
});
}
else if (expression is MetricVolumeExpression)
{
var tempExpression = (MetricVolumeExpression)expression;
return(new ImperialVolumeExpression {
Value = tempExpression.Value * (decimal)33.8140226
});
}
else
{
throw new InvalidExpressionException();
}
}
public override void VisitCatchClause(CatchClauseSyntax node)
{
MethodInfo mi = m_MethodInfoStack.Peek();
mi.TryCatchUsingOrLoopSwitchStack.Push(true);
ReturnContinueBreakAnalysis returnAnalysis = mi.TempReturnAnalysisStack.Peek();
string handledVar = string.Format("__catch_handled_{0}", GetSourcePosForVar(node));
string bodyVar = string.Format("__catch_body_{0}", GetSourcePosForVar(node));
CodeBuilder.AppendFormat("{0}(function({1}", GetIndentString(), handledVar);
if (null != node.Declaration)
{
CodeBuilder.Append(", ");
CodeBuilder.Append(node.Declaration.Identifier.Text);
}
CodeBuilder.Append("){");
CodeBuilder.AppendLine();
++m_Indent;
if (null != node.Filter)
{
CodeBuilder.Append("if(");
IConversionExpression opd = m_Model.GetOperation(node.Filter.FilterExpression) as IConversionExpression;
OutputExpressionSyntax(node.Filter.FilterExpression, opd);
CodeBuilder.Append("){");
CodeBuilder.AppendLine();
++m_Indent;
}
CodeBuilder.AppendFormat("{0}{1} = true;", GetIndentString(), handledVar);
CodeBuilder.AppendLine();
if (null != node.Filter)
{
--m_Indent;
CodeBuilder.AppendFormat("{0}}};", GetIndentString());
CodeBuilder.AppendLine();
}
if (returnAnalysis.Exist)
{
CodeBuilder.AppendFormat("{0}local({1}); {1} = function(){{", GetIndentString(), bodyVar);
CodeBuilder.AppendLine();
++m_Indent;
VisitBlock(node.Block);
--m_Indent;
CodeBuilder.AppendFormat("{0}}};", GetIndentString());
CodeBuilder.AppendLine();
CodeBuilder.AppendFormat("{0}return({1}, {2}());", GetIndentString(), handledVar, bodyVar);
CodeBuilder.AppendLine();
}
else
{
VisitBlock(node.Block);
CodeBuilder.AppendFormat("{0}return({1}, null);", GetIndentString(), handledVar);
CodeBuilder.AppendLine();
}
--m_Indent;
CodeBuilder.AppendFormat("{0}}})", GetIndentString());
CodeBuilder.AppendLine();
mi.TryCatchUsingOrLoopSwitchStack.Pop();
}
public override void VisitThrowStatement(ThrowStatementSyntax node)
{
CodeBuilder.AppendFormat("{0}luathrow(", GetIndentString());
IConversionExpression opd = m_Model.GetOperation(node.Expression) as IConversionExpression;
OutputExpressionSyntax(node.Expression, opd);
CodeBuilder.AppendLine(");");
}
/// <inheritdoc />
public override Expression VisitConversionExpression(IConversionExpression operation, LocalBinder argument)
{
return(Expression.Convert(
operation.Operand.Accept(this, argument),
operation.Type.GetCorrespondingType(),
operation.OperatorMethod?.GetCorrespondingMethod() as MethodInfo
));
}
public IConversionExpression BuildFrom(IEnumerable <IConversionToken> tokens)
{
foreach (var conversionToken in tokens)
{
conversionToken.Accept(this);
}
mResult = mCurrent;
return(mResult);
}
public override void VisitConversionExpression(IConversionExpression operation)
{
var usesOperatorMethod = operation.UsesOperatorMethod;
var operatorMethod = operation.OperatorMethod;
var converisionKind = operation.ConversionKind;
var isExplicit = operation.IsExplicit;
base.VisitConversionExpression(operation);
}
public override void VisitReturnStatement(ReturnStatementSyntax node)
{
MethodInfo mi = m_MethodInfoStack.Peek();
mi.ExistTopLevelReturn = IsLastNodeOfMethod(node);
bool isLastNode = IsLastNodeOfParent(node);
if (!isLastNode)
{
CodeBuilder.AppendFormat("{0}do", GetIndentString());
CodeBuilder.AppendLine();
}
string prestr;
if (mi.SemanticInfo.MethodKind == MethodKind.Constructor)
{
CodeBuilder.AppendFormat("{0}return this", GetIndentString());
prestr = ", ";
}
else
{
CodeBuilder.AppendFormat("{0}return ", GetIndentString());
prestr = string.Empty;
}
if (null != node.Expression)
{
CodeBuilder.Append(prestr);
IConversionExpression opd = null;
var iret = m_Model.GetOperation(node) as IReturnStatement;
if (null != iret)
{
opd = iret.ReturnedValue as IConversionExpression;
}
OutputExpressionSyntax(node.Expression, opd);
prestr = ", ";
}
var names = mi.ReturnParamNames;
if (names.Count > 0)
{
for (int i = 0; i < names.Count; ++i)
{
CodeBuilder.Append(prestr);
CodeBuilder.Append(names[i]);
prestr = ", ";
}
}
CodeBuilder.AppendLine(";");
if (!isLastNode)
{
CodeBuilder.AppendFormat("{0}end;", GetIndentString());
CodeBuilder.AppendLine();
}
}
public void Visit(MetricVolumeToken metricVolumeToken)
{
mCurrent = new MetricVolumeExpression {
Value = metricVolumeToken.Value
};
if (mCurrentOperation != null)
{
FillOperation();
}
}
public void Visit(ImperialVolumeToken imperialVolumeToken)
{
mCurrent = new ImperialVolumeExpression {
Value = imperialVolumeToken.Value
};
if (mCurrentOperation != null)
{
FillOperation();
}
}
void MakeReplacementWithDoubleConversion <TSelf>(IArithmeticConversionOperation operation,
IConversionExpression lhs, IConversionExpression rhs) where TSelf : IConversionExpressionWithValue, new()
{
var templhs = (TSelf)ConvertSingleExpression(rhs);
var temprhs = (TSelf)ConvertSingleExpression(lhs);
mReplacement = new TSelf
{
Value = CalculateValueForSpecificOperationType(operation, templhs.Value, temprhs.Value)
};
}
public IConversionExpressionWithValue Convert(IConversionExpression expression, bool toMetric)
{
mToMetric = toMetric;
mConverter = mConverterFactory(toMetric);
if (!CheckIfVisitorIsNecessary(expression))
{
return(ConvertSingleExpression(expression));
}
expression.Accept(this);
return(mResult);
}
public override void VisitArgument(ArgumentSyntax node)
{
var oper = m_Model.GetOperation(node) as IArgument;
IConversionExpression opd = null;
if (null != oper)
{
opd = oper.Value as IConversionExpression;
}
OutputExpressionSyntax(node.Expression, opd);
}
public override void VisitSimpleLambdaExpression(SimpleLambdaExpressionSyntax node)
{
SymbolInfo symInfo = m_Model.GetSymbolInfo(node);
var sym = symInfo.Symbol as IMethodSymbol;
if (null != sym && sym.Parameters.Length == 1)
{
if (node.Body is BlockSyntax)
{
var param = sym.Parameters[0];
CodeBuilder.AppendFormat("(function({0})", param.Name);
CodeBuilder.AppendLine();
++m_Indent;
node.Body.Accept(this);
if (!sym.ReturnsVoid)
{
CodeBuilder.AppendFormat("{0}return {1};", GetIndentString(), param.Name);
CodeBuilder.AppendLine();
}
--m_Indent;
CodeBuilder.AppendFormat("{0}end)", GetIndentString());
}
else
{
var param = sym.Parameters[0];
CodeBuilder.AppendFormat("(function({0}) return ", param.Name);
IConversionExpression opd = null;
var oper = m_Model.GetOperation(node) as ILambdaExpression;
if (null != oper && oper.Body.Statements.Length == 1)
{
var iret = oper.Body.Statements[0] as IReturnStatement;
if (null != iret)
{
opd = iret.ReturnedValue as IConversionExpression;
}
}
var exp = node.Body as ExpressionSyntax;
if (null != exp)
{
OutputExpressionSyntax(exp, opd);
}
else
{
ReportIllegalSymbol(node, symInfo);
}
CodeBuilder.Append("; end)");
}
}
else
{
ReportIllegalSymbol(node, symInfo);
}
}
void FillOperation()
{
if (mCurrentOperation.Left == null)
{
mCurrentOperation.Left = mCurrent;
}
else
{
mCurrentOperation.Right = mCurrent;
}
mCurrent = mCurrentOperation;
}
private static ITypeSymbol OriginalType(IOperation value)
{
if (value.Kind == OperationKind.ConversionExpression)
{
IConversionExpression conversion = (IConversionExpression)value;
if (!conversion.IsExplicit)
{
return(conversion.Operand.Type);
}
}
return(value.Type);
}
public override void VisitForEachStatement(ForEachStatementSyntax node)
{
ContinueInfo ci = new ContinueInfo();
ci.Init(node.Statement);
m_ContinueInfoStack.Push(ci);
string varName = string.Format("__compiler_foreach_{0}", node.GetLocation().GetLineSpan().StartLinePosition.Line);
CodeBuilder.AppendFormat("{0}local {1} = (", GetIndentString(), varName);
IConversionExpression opd = null;
var oper = m_Model.GetOperation(node) as IForEachLoopStatement;
if (null != oper)
{
opd = oper.Collection as IConversionExpression;
}
OutputExpressionSyntax(node.Expression, opd);
CodeBuilder.AppendLine("):GetEnumerator();");
CodeBuilder.AppendFormat("{0}while {1}:MoveNext() do", GetIndentString(), varName);
CodeBuilder.AppendLine();
if (ci.HaveContinue)
{
if (ci.HaveBreak)
{
CodeBuilder.AppendFormat("{0}local {1} = false", GetIndentString(), ci.BreakFlagVarName);
CodeBuilder.AppendLine();
}
CodeBuilder.AppendFormat("{0}repeat", GetIndentString());
CodeBuilder.AppendLine();
}
++m_Indent;
CodeBuilder.AppendFormat("{0}{1} = {2}.Current;", GetIndentString(), node.Identifier.Text, varName);
CodeBuilder.AppendLine();
node.Statement.Accept(this);
--m_Indent;
if (ci.HaveContinue)
{
CodeBuilder.AppendFormat("{0}until true;", GetIndentString());
CodeBuilder.AppendLine();
if (ci.HaveBreak)
{
CodeBuilder.AppendFormat("{0}if {1} then break; end;", GetIndentString(), ci.BreakFlagVarName);
CodeBuilder.AppendLine();
}
}
CodeBuilder.AppendFormat("{0}end;", GetIndentString());
CodeBuilder.AppendLine();
m_ContinueInfoStack.Pop();
}
public override void VisitConversionExpression(IConversionExpression operation)
{
LogString(nameof(IConversionExpression));
var kindStr = $"{nameof(ConversionKind)}.{operation.ConversionKind}";
var isExplicitStr = operation.IsExplicit ? "Explicit" : "Implicit";
LogString($" ({kindStr}, {isExplicitStr})");
LogHasOperatorMethodExpressionCommon(operation);
LogCommonPropertiesAndNewLine(operation);
base.VisitConversionExpression(operation);
}
public override void VisitDoStatement(DoStatementSyntax node)
{
MethodInfo mi = m_MethodInfoStack.Peek();
mi.TryCatchUsingOrLoopSwitchStack.Push(false);
ContinueInfo ci = new ContinueInfo();
ci.Init(node.Statement);
m_ContinueInfoStack.Push(ci);
CodeBuilder.AppendFormat("{0}do{{", GetIndentString());
CodeBuilder.AppendLine();
if (ci.HaveContinue)
{
if (ci.HaveBreak)
{
CodeBuilder.AppendFormat("{0}local({1}); {1} = false;", GetIndentString(), ci.BreakFlagVarName);
CodeBuilder.AppendLine();
}
CodeBuilder.AppendFormat("{0}do{{", GetIndentString());
CodeBuilder.AppendLine();
}
++m_Indent;
node.Statement.Accept(this);
--m_Indent;
if (ci.HaveContinue)
{
CodeBuilder.AppendFormat("{0}}}while(false);", GetIndentString());
CodeBuilder.AppendLine();
if (ci.HaveBreak)
{
CodeBuilder.AppendFormat("{0}if({1}){{break;}};", GetIndentString(), ci.BreakFlagVarName);
CodeBuilder.AppendLine();
}
}
CodeBuilder.AppendFormat("{0}}}while(", GetIndentString());
var oper = m_Model.GetOperationEx(node) as IWhileUntilLoopStatement;
IConversionExpression opd = null;
if (null != oper)
{
opd = oper.Condition as IConversionExpression;
}
OutputExpressionSyntax(node.Condition, opd);
CodeBuilder.AppendLine(");");
m_ContinueInfoStack.Pop();
mi.TryCatchUsingOrLoopSwitchStack.Pop();
}
private void AnalyzeObjectCreationForXmlReaderSettings(ISymbol variable, IObjectCreationExpression objCreation)
{
XmlReaderSettingsEnvironment xmlReaderSettingsEnv = new XmlReaderSettingsEnvironment(_isFrameworkSecure);
if (variable != null)
{
_xmlReaderSettingsEnvironments[variable] = xmlReaderSettingsEnv;
}
xmlReaderSettingsEnv.XmlReaderSettingsDefinition = objCreation.Syntax;
foreach (ISymbolInitializer init in objCreation.MemberInitializers)
{
var prop = init as IPropertyInitializer;
if (prop != null)
{
if (SecurityDiagnosticHelpers.IsXmlReaderSettingsXmlResolverProperty(
prop.InitializedProperty,
_xmlTypes)
)
{
IConversionExpression operation = prop.Value as IConversionExpression;
if (operation == null)
{
return;
}
if (SecurityDiagnosticHelpers.IsXmlSecureResolverType(operation.Operand.Type, _xmlTypes))
{
xmlReaderSettingsEnv.IsSecureResolver = true;
}
else if (SecurityDiagnosticHelpers.IsExpressionEqualsNull(operation.Operand))
{
xmlReaderSettingsEnv.IsSecureResolver = true;
}
}
else if (SecurityDiagnosticHelpers.IsXmlReaderSettingsDtdProcessingProperty(prop.InitializedProperty, _xmlTypes))
{
xmlReaderSettingsEnv.IsDtdProcessingDisabled = !SecurityDiagnosticHelpers.IsExpressionEqualsDtdProcessingParse(prop.Value);
}
else if (SecurityDiagnosticHelpers.IsXmlReaderSettingsMaxCharactersFromEntitiesProperty(prop.InitializedProperty, _xmlTypes))
{
xmlReaderSettingsEnv.IsMaxCharactersFromEntitiesLimited = !SecurityDiagnosticHelpers.IsExpressionEqualsIntZero(prop.Value);
}
}
}
}
public override void ReplaceChild(IConversionExpression oldChild, IConversionExpression newChild)
{
if (ReferenceEquals(oldChild, mLeft))
{
oldChild.Parent(null);
Left = newChild;
}
else if (ReferenceEquals(oldChild, mRight))
{
oldChild.Parent(null);
Right = newChild;
}
else
{
throw new ArgumentException();
}
}
public override void VisitDoStatement(DoStatementSyntax node)
{
ContinueInfo ci = new ContinueInfo();
ci.Init(node.Statement);
m_ContinueInfoStack.Push(ci);
CodeBuilder.AppendFormat("{0}repeat", GetIndentString());
CodeBuilder.AppendLine();
if (ci.HaveContinue)
{
if (ci.HaveBreak)
{
CodeBuilder.AppendFormat("{0}local {1} = false", GetIndentString(), ci.BreakFlagVarName);
CodeBuilder.AppendLine();
}
CodeBuilder.AppendFormat("{0}repeat", GetIndentString());
CodeBuilder.AppendLine();
}
++m_Indent;
node.Statement.Accept(this);
--m_Indent;
if (ci.HaveContinue)
{
CodeBuilder.AppendFormat("{0}until true;", GetIndentString());
CodeBuilder.AppendLine();
if (ci.HaveBreak)
{
CodeBuilder.AppendFormat("{0}if {1} then break; end;", GetIndentString(), ci.BreakFlagVarName);
CodeBuilder.AppendLine();
}
}
CodeBuilder.AppendFormat("{0}until not (", GetIndentString());
var oper = m_Model.GetOperation(node) as IWhileUntilLoopStatement;
IConversionExpression opd = null;
if (null != oper)
{
opd = oper.Condition as IConversionExpression;
}
OutputExpressionSyntax(node.Condition, opd);
CodeBuilder.AppendLine(");");
m_ContinueInfoStack.Pop();
}
public override void VisitUsingStatement(UsingStatementSyntax node)
{
string varName = string.Format("__compiler_using_{0}", GetSourcePosForVar(node));
if (null != node.Declaration)
{
VisitVariableDeclaration(node.Declaration);
}
else if (null != node.Expression)
{
CodeBuilder.AppendFormat("{0}local {1} = ", GetIndentString(), varName);
IConversionExpression opd = m_Model.GetOperation(node.Expression) as IConversionExpression;
OutputExpressionSyntax(node.Expression, opd);
CodeBuilder.AppendLine(";");
}
else
{
Log(node, "node.Declaration and node.Expression are null.");
}
if (null != node.Statement)
{
node.Statement.Accept(this);
}
else
{
Log(node, "node.Statement is null.");
}
if (null != node.Declaration && null != node.Declaration.Variables)
{
foreach (var decl in node.Declaration.Variables)
{
CodeBuilder.AppendFormat("{0}{1}:Dispose();", GetIndentString(), decl.Identifier.Text);
CodeBuilder.AppendLine();
}
}
else if (null != node.Expression)
{
CodeBuilder.AppendFormat("{0}{1}:Dispose();", GetIndentString(), varName);
CodeBuilder.AppendLine();
}
else
{
Log(node, "node.Declaration is null or node.Declaration.Variables is null, and node.Expression is null.");
}
}
private void AnalyzeXmlTextReaderProperties(OperationAnalysisContext context, ISymbol assignedSymbol, IAssignmentExpression expression, bool isXmlTextReaderXmlResolverProperty, bool isXmlTextReaderDtdProcessingProperty)
{
XmlTextReaderEnvironment env;
if (!_xmlTextReaderEnvironments.TryGetValue(assignedSymbol, out env))
{
env = new XmlTextReaderEnvironment(_isFrameworkSecure);
}
if (isXmlTextReaderXmlResolverProperty)
{
env.IsXmlResolverSet = true;
}
else
{
env.IsDtdProcessingSet = true;
}
IConversionExpression conv = expression.Value as IConversionExpression;
if (isXmlTextReaderXmlResolverProperty && conv != null && SecurityDiagnosticHelpers.IsXmlSecureResolverType(conv.Operand.Type, _xmlTypes))
{
env.IsSecureResolver = true;
}
else if (isXmlTextReaderXmlResolverProperty && conv != null && SecurityDiagnosticHelpers.IsExpressionEqualsNull(conv.Operand))
{
env.IsSecureResolver = true;
}
else if (isXmlTextReaderDtdProcessingProperty && conv == null && !SecurityDiagnosticHelpers.IsExpressionEqualsDtdProcessingParse(expression.Value))
{
env.IsDtdProcessingDisabled = !SecurityDiagnosticHelpers.IsExpressionEqualsDtdProcessingParse(expression.Value);
}
else
{
// Generate a warning whenever the XmlResolver or DtdProcessing property is set to an insecure value
Diagnostic diag = Diagnostic.Create(
RuleDoNotUseInsecureDtdProcessing,
expression.Syntax.GetLocation(),
SecurityDiagnosticHelpers.GetLocalizableResourceString(
nameof(DesktopAnalyzersResources.XmlTextReaderSetInsecureResolutionMessage)
)
);
context.ReportDiagnostic(diag);
}
}
public override void VisitConversionExpression(IConversionExpression operation)
{
var usesOperatorMethod = operation.UsesOperatorMethod;
var operatorMethod = operation.OperatorMethod;
var converisionKind = operation.ConversionKind;
var isExplicit = operation.IsExplicit;
base.VisitConversionExpression(operation);
}
public virtual void VisitConversionExpression(IConversionExpression operation)
{
DefaultVisit(operation);
}
