Move classes to seperate files

Author: tamasvajk

csharp/extractor/Semmle.Extraction.CSharp/Entities/CallTypeExtensions.cs

@@ -0,0 +1,27 @@
+using Semmle.Extraction.Kinds;
+
+namespace Semmle.Extraction.CSharp.Entities
+{
+    internal static class CallTypeExtensions
+    {
+        /// <summary>
+        /// Adjust the expression kind <paramref name="k"/> to match this call type.
+        /// </summary>
+        public static ExprKind AdjustKind(this Expression.CallType ct, ExprKind k)
+        {
+            if (k == ExprKind.ADDRESS_OF)
+            {
+                return k;
+            }
+
+            switch (ct)
+            {
+                case Expression.CallType.Dynamic:
+                case Expression.CallType.UserOperator:
+                    return ExprKind.OPERATOR_INVOCATION;
+                default:
+                    return k;
+            }
+        }
+    }
+}

csharp/extractor/Semmle.Extraction.CSharp/Entities/Expression.cs

@@ -2,23 +2,13 @@
 using Microsoft.CodeAnalysis.CSharp;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Semmle.Extraction.CSharp.Entities.Expressions;
-using Semmle.Extraction.CSharp.Populators;
-using Semmle.Extraction.Entities;
 using Semmle.Extraction.Kinds;
 using System;
 using System.IO;
 using System.Linq;
 
 namespace Semmle.Extraction.CSharp.Entities
 {
-    public interface IExpressionParentEntity : IEntity
-    {
-        /// <summary>
-        /// Whether this entity is the parent of a top-level expression.
-        /// </summary>
-        bool IsTopLevelParent { get; }
-    }
-
     internal class Expression : FreshEntity, IExpressionParentEntity
     {
         private readonly IExpressionInfo info;
@@ -308,314 +298,4 @@ private void PopulateArgument(TextWriter trapFile, ArgumentSyntax arg, int child
 
         public override TrapStackBehaviour TrapStackBehaviour => TrapStackBehaviour.OptionalLabel;
     }
-
-    internal static class CallTypeExtensions
-    {
-        /// <summary>
-        /// Adjust the expression kind <paramref name="k"/> to match this call type.
-        /// </summary>
-        public static ExprKind AdjustKind(this Expression.CallType ct, ExprKind k)
-        {
-            if (k == ExprKind.ADDRESS_OF)
-            {
-                return k;
-            }
-
-            switch (ct)
-            {
-                case Expression.CallType.Dynamic:
-                case Expression.CallType.UserOperator:
-                    return ExprKind.OPERATOR_INVOCATION;
-                default:
-                    return k;
-            }
-        }
-    }
-
-    internal abstract class Expression<TExpressionSyntax> : Expression
-        where TExpressionSyntax : ExpressionSyntax
-    {
-        public TExpressionSyntax Syntax { get; }
-
-        protected Expression(ExpressionNodeInfo info)
-            : base(info)
-        {
-            Syntax = (TExpressionSyntax)info.Node;
-        }
-
-        /// <summary>
-        /// Populates expression-type specific relations in the trap file. The general relations
-        /// <code>expressions</code> and <code>expr_location</code> are populated by the constructor
-        /// (should not fail), so even if expression-type specific population fails (e.g., in
-        /// standalone extraction), the expression created via
-        /// <see cref="Expression.Create(Context, ExpressionSyntax, IEntity, int, ITypeSymbol)"/> will
-        /// still be valid.
-        /// </summary>
-        protected abstract void PopulateExpression(TextWriter trapFile);
-
-        protected new Expression TryPopulate()
-        {
-            cx.Try(Syntax, null, () => PopulateExpression(cx.TrapWriter.Writer));
-            return this;
-        }
-    }
-
-    /// <summary>
-    /// Holds all information required to create an Expression entity.
-    /// </summary>
-    internal interface IExpressionInfo
-    {
-        Context Context { get; }
-
-        /// <summary>
-        /// The type of the expression.
-        /// </summary>
-        AnnotatedTypeSymbol? Type { get; }
-
-        /// <summary>
-        /// The location of the expression.
-        /// </summary>
-        Extraction.Entities.Location Location { get; }
-
-        /// <summary>
-        /// The kind of the expression.
-        /// </summary>
-        ExprKind Kind { get; }
-
-        /// <summary>
-        /// The parent of the expression.
-        /// </summary>
-        IExpressionParentEntity Parent { get; }
-
-        /// <summary>
-        /// The child index of the expression.
-        /// </summary>
-        int Child { get; }
-
-        /// <summary>
-        /// Holds if this is an implicit expression.
-        /// </summary>
-        bool IsCompilerGenerated { get; }
-
-        /// <summary>
-        /// Gets a string representation of the value.
-        /// null is encoded as the string "null".
-        /// If the expression does not have a value, then this
-        /// is null.
-        /// </summary>
-        string ExprValue { get; }
-
-        NullableFlowState FlowState { get; }
-    }
-
-    /// <summary>
-    /// Explicitly constructed expression information.
-    /// </summary>
-    internal class ExpressionInfo : IExpressionInfo
-    {
-        public Context Context { get; }
-        public AnnotatedTypeSymbol? Type { get; }
-        public Extraction.Entities.Location Location { get; }
-        public ExprKind Kind { get; }
-        public IExpressionParentEntity Parent { get; }
-        public int Child { get; }
-        public bool IsCompilerGenerated { get; }
-        public string ExprValue { get; }
-
-        public ExpressionInfo(Context cx, AnnotatedTypeSymbol? type, Extraction.Entities.Location location, ExprKind kind,
-            IExpressionParentEntity parent, int child, bool isCompilerGenerated, string value)
-        {
-            Context = cx;
-            Type = type;
-            Location = location;
-            Kind = kind;
-            Parent = parent;
-            Child = child;
-            ExprValue = value;
-            IsCompilerGenerated = isCompilerGenerated;
-        }
-
-        // Synthetic expressions don't have a flow state.
-        public NullableFlowState FlowState => NullableFlowState.None;
-    }
-
-    /// <summary>
-    /// Expression information constructed from a syntax node.
-    /// </summary>
-    internal class ExpressionNodeInfo : IExpressionInfo
-    {
-        public ExpressionNodeInfo(Context cx, ExpressionSyntax node, IExpressionParentEntity parent, int child) :
-            this(cx, node, parent, child, cx.GetTypeInfo(node))
-        {
-        }
-
-        public ExpressionNodeInfo(Context cx, ExpressionSyntax node, IExpressionParentEntity parent, int child, TypeInfo typeInfo)
-        {
-            Context = cx;
-            Node = node;
-            Parent = parent;
-            Child = child;
-            TypeInfo = typeInfo;
-            Conversion = cx.GetModel(node).GetConversion(node);
-        }
-
-        public Context Context { get; }
-        public ExpressionSyntax Node { get; private set; }
-        public IExpressionParentEntity Parent { get; set; }
-        public int Child { get; set; }
-        public TypeInfo TypeInfo { get; }
-        public Microsoft.CodeAnalysis.CSharp.Conversion Conversion { get; }
-
-        public AnnotatedTypeSymbol ResolvedType => new AnnotatedTypeSymbol(TypeInfo.Type.DisambiguateType(), TypeInfo.Nullability.Annotation);
-        public AnnotatedTypeSymbol ConvertedType => new AnnotatedTypeSymbol(TypeInfo.ConvertedType.DisambiguateType(), TypeInfo.ConvertedNullability.Annotation);
-
-        private AnnotatedTypeSymbol? cachedType;
-        private bool cachedTypeSet;
-        public AnnotatedTypeSymbol? Type
-        {
-            get
-            {
-                if (cachedTypeSet)
-                    return cachedType;
-
-                var type = ResolvedType;
-
-                if (type.Symbol == null)
-                    type.Symbol = (TypeInfo.Type ?? TypeInfo.ConvertedType).DisambiguateType();
-
-                // Roslyn workaround: It can't work out the type of "new object[0]"
-                // Clearly a bug.
-                if (type.Symbol?.TypeKind == Microsoft.CodeAnalysis.TypeKind.Error)
-                {
-                    if (Node is ArrayCreationExpressionSyntax arrayCreation)
-                    {
-                        var elementType = Context.GetType(arrayCreation.Type.ElementType);
-
-                        if (elementType.Symbol != null)
-                            // There seems to be no way to create an array with a nullable element at present.
-                            return new AnnotatedTypeSymbol(Context.Compilation.CreateArrayTypeSymbol(elementType.Symbol, arrayCreation.Type.RankSpecifiers.Count), NullableAnnotation.NotAnnotated);
-                    }
-
-                    Context.ModelError(Node, "Failed to determine type");
-                }
-
-                cachedType = type;
-                cachedTypeSet = true;
-
-                return type;
-            }
-        }
-
-        private Microsoft.CodeAnalysis.Location location;
-
-        public Microsoft.CodeAnalysis.Location CodeAnalysisLocation
-        {
-            get
-            {
-                if (location == null)
-                    location = Node.FixedLocation();
-                return location;
-            }
-            set
-            {
-                location = value;
-            }
-        }
-
-        public SemanticModel Model => Context.GetModel(Node);
-
-        public string ExprValue
-        {
-            get
-            {
-                var c = Model.GetConstantValue(Node);
-                if (c.HasValue)
-                {
-                    return Expression.ValueAsString(c.Value);
-                }
-
-                if (TryGetBoolValueFromLiteral(out var val))
-                {
-                    return Expression.ValueAsString(val);
-                }
-
-                return null;
-            }
-        }
-
-        private Extraction.Entities.Location cachedLocation;
-
-        public Extraction.Entities.Location Location
-        {
-            get
-            {
-                if (cachedLocation == null)
-                    cachedLocation = Context.Create(CodeAnalysisLocation);
-                return cachedLocation;
-            }
-
-            set
-            {
-                cachedLocation = value;
-            }
-        }
-
-        public ExprKind Kind { get; set; } = ExprKind.UNKNOWN;
-
-        public bool IsCompilerGenerated { get; set; }
-
-        public ExpressionNodeInfo SetParent(IExpressionParentEntity parent, int child)
-        {
-            Parent = parent;
-            Child = child;
-            return this;
-        }
-
-        public ExpressionNodeInfo SetKind(ExprKind kind)
-        {
-            Kind = kind;
-            return this;
-        }
-
-        public ExpressionNodeInfo SetType(AnnotatedTypeSymbol? type)
-        {
-            cachedType = type;
-            cachedTypeSet = true;
-            return this;
-        }
-
-        public ExpressionNodeInfo SetNode(ExpressionSyntax node)
-        {
-            Node = node;
-            return this;
-        }
-
-        private SymbolInfo cachedSymbolInfo;
-
-        public SymbolInfo SymbolInfo
-        {
-            get
-            {
-                if (cachedSymbolInfo.Symbol == null && cachedSymbolInfo.CandidateReason == CandidateReason.None)
-                    cachedSymbolInfo = Model.GetSymbolInfo(Node);
-                return cachedSymbolInfo;
-            }
-        }
-
-        public NullableFlowState FlowState => TypeInfo.Nullability.FlowState;
-
-        private bool TryGetBoolValueFromLiteral(out bool val)
-        {
-            var isTrue = Node.IsKind(SyntaxKind.TrueLiteralExpression);
-            var isFalse = Node.IsKind(SyntaxKind.FalseLiteralExpression);
-
-            val = isTrue;
-            return isTrue || isFalse;
-        }
-
-        public bool IsBoolLiteral()
-        {
-            return TryGetBoolValueFromLiteral(out var _);
-        }
-    }
 }