mcs/class/dlr/Runtime/Microsoft.Scripting.Core/Ast/ExpressionType.cs

   1 /* ****************************************************************************
   2  *
   3  * Copyright (c) Microsoft Corporation.
   4  *
   5  * This source code is subject to terms and conditions of the Apache License, Version 2.0. A
   6  * copy of the license can be found in the License.html file at the root of this distribution. If
   7  * you cannot locate the  Apache License, Version 2.0, please send an email to
   8  * dlr@microsoft.com. By using this source code in any fashion, you are agreeing to be bound
   9  * by the terms of the Apache License, Version 2.0.
  10  *
  11  * You must not remove this notice, or any other, from this software.
  12  *
  13  *
  14  * ***************************************************************************/
  15
  16 #if !FEATURE_CORE_DLR
  17 namespace Microsoft.Scripting.Ast {
  18 #else
  19 namespace System.Linq.Expressions {
  20 #endif
  21
  22     /// <summary>
  23     /// Describes the node types for the nodes of an expression tree.
  24     /// </summary>
  25     public enum ExpressionType {
  26
  27         #region Generated Expression Tree Node Types
  28
  29         // *** BEGIN GENERATED CODE ***
  30         // generated by function: gen_tree_nodes from: generate_tree.py
  31
  32         /// <summary>
  33         /// A node that represents arithmetic addition without overflow checking.
  34         /// </summary>
  35         Add,
  36         /// <summary>
  37         /// A node that represents arithmetic addition with overflow checking.
  38         /// </summary>
  39         AddChecked,
  40         /// <summary>
  41         /// A node that represents a bitwise AND operation.
  42         /// </summary>
  43         And,
  44         /// <summary>
  45         /// A node that represents a short-circuiting conditional AND operation.
  46         /// </summary>
  47         AndAlso,
  48         /// <summary>
  49         /// A node that represents getting the length of a one-dimensional array.
  50         /// </summary>
  51         ArrayLength,
  52         /// <summary>
  53         /// A node that represents indexing into a one-dimensional array.
  54         /// </summary>
  55         ArrayIndex,
  56         /// <summary>
  57         /// A node that represents represents a method call.
  58         /// </summary>
  59         Call,
  60         /// <summary>
  61         /// A node that represents a null coalescing operation.
  62         /// </summary>
  63         Coalesce,
  64         /// <summary>
  65         /// A node that represents a conditional operation.
  66         /// </summary>
  67         Conditional,
  68         /// <summary>
  69         /// A node that represents an expression that has a constant value.
  70         /// </summary>
  71         Constant,
  72         /// <summary>
  73         /// A node that represents a cast or conversion operation. If the operation is a numeric conversion, it overflows silently if the converted value does not fit the target type.
  74         /// </summary>
  75         Convert,
  76         /// <summary>
  77         /// A node that represents a cast or conversion operation. If the operation is a numeric conversion, an exception is thrown if the converted value does not fit the target type.
  78         /// </summary>
  79         ConvertChecked,
  80         /// <summary>
  81         /// A node that represents arithmetic division.
  82         /// </summary>
  83         Divide,
  84         /// <summary>
  85         /// A node that represents an equality comparison.
  86         /// </summary>
  87         Equal,
  88         /// <summary>
  89         /// A node that represents a bitwise XOR operation.
  90         /// </summary>
  91         ExclusiveOr,
  92         /// <summary>
  93         /// A node that represents a "greater than" numeric comparison.
  94         /// </summary>
  95         GreaterThan,
  96         /// <summary>
  97         /// A node that represents a "greater than or equal" numeric comparison.
  98         /// </summary>
  99         GreaterThanOrEqual,
 100         /// <summary>
 101         /// A node that represents applying a delegate or lambda expression to a list of argument expressions.
 102         /// </summary>
 103         Invoke,
 104         /// <summary>
 105         /// A node that represents a lambda expression.
 106         /// </summary>
 107         Lambda,
 108         /// <summary>
 109         /// A node that represents a bitwise left-shift operation.
 110         /// </summary>
 111         LeftShift,
 112         /// <summary>
 113         /// A node that represents a "less than" numeric comparison.
 114         /// </summary>
 115         LessThan,
 116         /// <summary>
 117         /// A node that represents a "less than or equal" numeric comparison.
 118         /// </summary>
 119         LessThanOrEqual,
 120         /// <summary>
 121         /// A node that represents creating a new IEnumerable object and initializing it from a list of elements.
 122         /// </summary>
 123         ListInit,
 124         /// <summary>
 125         /// A node that represents reading from a field or property.
 126         /// </summary>
 127         MemberAccess,
 128         /// <summary>
 129         /// A node that represents creating a new object and initializing one or more of its members.
 130         /// </summary>
 131         MemberInit,
 132         /// <summary>
 133         /// A node that represents an arithmetic remainder operation.
 134         /// </summary>
 135         Modulo,
 136         /// <summary>
 137         /// A node that represents arithmetic multiplication without overflow checking.
 138         /// </summary>
 139         Multiply,
 140         /// <summary>
 141         /// A node that represents arithmetic multiplication with overflow checking.
 142         /// </summary>
 143         MultiplyChecked,
 144         /// <summary>
 145         /// A node that represents an arithmetic negation operation.
 146         /// </summary>
 147         Negate,
 148         /// <summary>
 149         /// A node that represents a unary plus operation. The result of a predefined unary plus operation is simply the value of the operand, but user-defined implementations may have non-trivial results.
 150         /// </summary>
 151         UnaryPlus,
 152         /// <summary>
 153         /// A node that represents an arithmetic negation operation that has overflow checking.
 154         /// </summary>
 155         NegateChecked,
 156         /// <summary>
 157         /// A node that represents calling a constructor to create a new object.
 158         /// </summary>
 159         New,
 160         /// <summary>
 161         /// A node that represents creating a new one-dimensional array and initializing it from a list of elements.
 162         /// </summary>
 163         NewArrayInit,
 164         /// <summary>
 165         /// A node that represents creating a new array where the bounds for each dimension are specified.
 166         /// </summary>
 167         NewArrayBounds,
 168         /// <summary>
 169         /// A node that represents a bitwise complement operation.
 170         /// </summary>
 171         Not,
 172         /// <summary>
 173         /// A node that represents an inequality comparison.
 174         /// </summary>
 175         NotEqual,
 176         /// <summary>
 177         /// A node that represents a bitwise OR operation.
 178         /// </summary>
 179         Or,
 180         /// <summary>
 181         /// A node that represents a short-circuiting conditional OR operation.
 182         /// </summary>
 183         OrElse,
 184         /// <summary>
 185         /// A node that represents a reference to a parameter or variable defined in the context of the expression.
 186         /// </summary>
 187         Parameter,
 188         /// <summary>
 189         /// A node that represents raising a number to a power.
 190         /// </summary>
 191         Power,
 192         /// <summary>
 193         /// A node that represents an expression that has a constant value of type Expression. A Quote node can contain references to parameters defined in the context of the expression it represents.
 194         /// </summary>
 195         Quote,
 196         /// <summary>
 197         /// A node that represents a bitwise right-shift operation.
 198         /// </summary>
 199         RightShift,
 200         /// <summary>
 201         /// A node that represents arithmetic subtraction without overflow checking.
 202         /// </summary>
 203         Subtract,
 204         /// <summary>
 205         /// A node that represents arithmetic subtraction with overflow checking.
 206         /// </summary>
 207         SubtractChecked,
 208         /// <summary>
 209         /// A node that represents an explicit reference or boxing conversion where null reference (Nothing in Visual Basic) is supplied if the conversion fails.
 210         /// </summary>
 211         TypeAs,
 212         /// <summary>
 213         /// A node that represents a type test.
 214         /// </summary>
 215         TypeIs,
 216         /// <summary>
 217         /// A node that represents an assignment.
 218         /// </summary>
 219         Assign,
 220         /// <summary>
 221         /// A node that represents a block of expressions.
 222         /// </summary>
 223         Block,
 224         /// <summary>
 225         /// A node that represents a debugging information.
 226         /// </summary>
 227         DebugInfo,
 228         /// <summary>
 229         /// A node that represents a unary decrement.
 230         /// </summary>
 231         Decrement,
 232         /// <summary>
 233         /// A node that represents a dynamic operation.
 234         /// </summary>
 235         Dynamic,
 236         /// <summary>
 237         /// A node that represents a default value.
 238         /// </summary>
 239         Default,
 240         /// <summary>
 241         /// A node that represents an extension expression.
 242         /// </summary>
 243         Extension,
 244         /// <summary>
 245         /// A node that represents a goto.
 246         /// </summary>
 247         Goto,
 248         /// <summary>
 249         /// A node that represents a unary increment.
 250         /// </summary>
 251         Increment,
 252         /// <summary>
 253         /// A node that represents an index operation.
 254         /// </summary>
 255         Index,
 256         /// <summary>
 257         /// A node that represents a label.
 258         /// </summary>
 259         Label,
 260         /// <summary>
 261         /// A node that represents a list of runtime variables.
 262         /// </summary>
 263         RuntimeVariables,
 264         /// <summary>
 265         /// A node that represents a loop.
 266         /// </summary>
 267         Loop,
 268         /// <summary>
 269         /// A node that represents a switch operation.
 270         /// </summary>
 271         Switch,
 272         /// <summary>
 273         /// A node that represents a throwing of an exception.
 274         /// </summary>
 275         Throw,
 276         /// <summary>
 277         /// A node that represents a try-catch expression.
 278         /// </summary>
 279         Try,
 280         /// <summary>
 281         /// A node that represents an unbox value type operation.
 282         /// </summary>
 283         Unbox,
 284         /// <summary>
 285         /// A node that represents an arithmetic addition compound assignment without overflow checking.
 286         /// </summary>
 287         AddAssign,
 288         /// <summary>
 289         /// A node that represents a bitwise AND compound assignment.
 290         /// </summary>
 291         AndAssign,
 292         /// <summary>
 293         /// A node that represents an arithmetic division compound assignment .
 294         /// </summary>
 295         DivideAssign,
 296         /// <summary>
 297         /// A node that represents a bitwise XOR compound assignment.
 298         /// </summary>
 299         ExclusiveOrAssign,
 300         /// <summary>
 301         /// A node that represents a bitwise left-shift compound assignment.
 302         /// </summary>
 303         LeftShiftAssign,
 304         /// <summary>
 305         /// A node that represents an arithmetic remainder compound assignment.
 306         /// </summary>
 307         ModuloAssign,
 308         /// <summary>
 309         /// A node that represents arithmetic multiplication compound assignment without overflow checking.
 310         /// </summary>
 311         MultiplyAssign,
 312         /// <summary>
 313         /// A node that represents a bitwise OR compound assignment.
 314         /// </summary>
 315         OrAssign,
 316         /// <summary>
 317         /// A node that represents raising a number to a power compound assignment.
 318         /// </summary>
 319         PowerAssign,
 320         /// <summary>
 321         /// A node that represents a bitwise right-shift compound assignment.
 322         /// </summary>
 323         RightShiftAssign,
 324         /// <summary>
 325         /// A node that represents arithmetic subtraction compound assignment without overflow checking.
 326         /// </summary>
 327         SubtractAssign,
 328         /// <summary>
 329         /// A node that represents an arithmetic addition compound assignment with overflow checking.
 330         /// </summary>
 331         AddAssignChecked,
 332         /// <summary>
 333         /// A node that represents arithmetic multiplication compound assignment with overflow checking.
 334         /// </summary>
 335         MultiplyAssignChecked,
 336         /// <summary>
 337         /// A node that represents arithmetic subtraction compound assignment with overflow checking.
 338         /// </summary>
 339         SubtractAssignChecked,
 340         /// <summary>
 341         /// A node that represents an unary prefix increment.
 342         /// </summary>
 343         PreIncrementAssign,
 344         /// <summary>
 345         /// A node that represents an unary prefix decrement.
 346         /// </summary>
 347         PreDecrementAssign,
 348         /// <summary>
 349         /// A node that represents an unary postfix increment.
 350         /// </summary>
 351         PostIncrementAssign,
 352         /// <summary>
 353         /// A node that represents an unary postfix decrement.
 354         /// </summary>
 355         PostDecrementAssign,
 356         /// <summary>
 357         /// A node that represents a exact type test.
 358         /// </summary>
 359         TypeEqual,
 360         /// <summary>
 361         /// A node that represents a ones complement.
 362         /// </summary>
 363         OnesComplement,
 364         /// <summary>
 365         /// A node that represents a true condition value.
 366         /// </summary>
 367         IsTrue,
 368         /// <summary>
 369         /// A node that represents a false condition value.
 370         /// </summary>
 371         IsFalse,
 372
 373         // *** END GENERATED CODE ***
 374
 375         #endregion
 376     }
 377 }