Struct VariableDeclaration

pub struct VariableDeclaration {

    pub base_functions: Option<Vec<i64>>,
    pub constant: bool,
    pub documentation: Option<StructuredDocumentation>,
    pub function_selector: Option<String>,
    pub id: i64,
    pub indexed: Option<bool>,
    pub mutability: Mutability,
    pub name: String,
    pub name_location: Option<String>,
    pub node_type: VariableDeclarationNodeType,
    pub overrides: Option<OverrideSpecifier>,
    pub scope: i64,
    pub src: SourceLocation,
    pub state_variable: bool,
    pub storage_location: StorageLocation,
    pub type_descriptions: TypeDescriptions,
    pub type_name: Option<TypeName>,
    pub value: Option<Expression>,
    pub visibility: Visibility,
}

VariableDeclaration

JSON schema

{
 "type": "object",
 "required": [
   "constant",
   "id",
   "mutability",
   "name",
   "nodeType",
   "scope",
   "src",
   "stateVariable",
   "storageLocation",
   "typeDescriptions",
   "visibility"
 ],
 "properties": {
   "baseFunctions": {
     "anyOf": [
       {
         "type": "array",
         "items": {
           "type": "integer"
         }
       },
       {
         "type": "null"
       }
     ]
   },
   "constant": {
     "type": "boolean"
   },
   "documentation": {
     "anyOf": [
       {
         "$ref": "#/definitions/StructuredDocumentation"
       },
       {
         "type": "null"
       }
     ]
   },
   "functionSelector": {
     "type": "string"
   },
   "id": {
     "type": "integer"
   },
   "indexed": {
     "type": "boolean"
   },
   "mutability": {
     "$ref": "#/definitions/Mutability"
   },
   "name": {
     "type": "string"
   },
   "nameLocation": {
     "type": "string"
   },
   "nodeType": {
     "enum": [
       "VariableDeclaration"
     ]
   },
   "overrides": {
     "anyOf": [
       {
         "$ref": "#/definitions/OverrideSpecifier"
       },
       {
         "type": "null"
       }
     ]
   },
   "scope": {
     "type": "integer"
   },
   "src": {
     "$ref": "#/definitions/SourceLocation"
   },
   "stateVariable": {
     "type": "boolean"
   },
   "storageLocation": {
     "$ref": "#/definitions/StorageLocation"
   },
   "typeDescriptions": {
     "$ref": "#/definitions/TypeDescriptions"
   },
   "typeName": {
     "anyOf": [
       {
         "$ref": "#/definitions/TypeName"
       },
       {
         "type": "null"
       }
     ]
   },
   "value": {
     "anyOf": [
       {
         "$ref": "#/definitions/Expression"
       },
       {
         "type": "null"
       }
     ]
   },
   "visibility": {
     "$ref": "#/definitions/Visibility"
   }
 },
 "additionalProperties": false
}

Fields

base_functions: Option<Vec<i64>>

constant: bool

documentation: Option<StructuredDocumentation>

function_selector: Option<String>

id: i64

indexed: Option<bool>

mutability: Mutability

name: String

name_location: Option<String>

node_type: VariableDeclarationNodeType

overrides: Option<OverrideSpecifier>

scope: i64

src: SourceLocation

state_variable: bool

storage_location: StorageLocation

type_descriptions: TypeDescriptions

type_name: Option<TypeName>

value: Option<Expression>

visibility: Visibility

Trait Implementations

impl Clone for VariableDeclaration

fn clone(&self) -> VariableDeclaration

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for VariableDeclaration

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for VariableDeclaration

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<&VariableDeclaration> for VariableDeclaration

fn from(value: &VariableDeclaration) -> Self

Converts to this type from the input type.

impl From<VariableDeclaration> for ContractDefinitionNodesItem

fn from(value: VariableDeclaration) -> Self

Converts to this type from the input type.

impl From<VariableDeclaration> for SourceUnitNodesItem

fn from(value: VariableDeclaration) -> Self

Converts to this type from the input type.

impl Serialize for VariableDeclaration

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.