Skip to content

Latest commit

 

History

History
888 lines (754 loc) · 53 KB

Changelog.md

File metadata and controls

888 lines (754 loc) · 53 KB
Raw

0.5.0 (unreleased)

How to update your code:

  • Change every .call() to a .call("") and every .call(signature, a, b, c) to use .call(abi.encodeWithSignature(signature, a, b, c)) (the last one only works for value types).
  • Change every keccak256(a, b, c) to keccak256(abi.encodePacked(a, b, c)).
  • Add public to every function and external to every fallback or interface function that does not specify its visibility already.
  • Make your fallback functions external.
  • Explicitly state the data location for all variables of struct, array or mapping types (including function parameters), e.g. change uint[] x = m_x to uint[] storage x = m_x. Note that external functions require parameters with a data location of calldata.
  • Explicitly convert values of contract type to addresses before using an address member. Example: if c is a contract, change c.transfer(...) to address(c).transfer(...).
  • Declare variables and especially function arguments as address payable, if you want to call transfer on them.

Breaking Changes:

  • ABI Encoder: Properly pad data from calldata (msg.data and external function parameters). Use abi.encodePacked for unpadded encoding.
  • Code Generator: Signed right shift uses proper arithmetic shift, i.e. rounding towards negative infinity. Warning: this may silently change the semantics of existing code!
  • Code Generator: Revert at runtime if calldata is too short or points out of bounds. This is done inside the ABI decoder and therefore also applies to abi.decode().
  • Code Generator: Use STATICCALL for pure and view functions. This was already the case in the experimental 0.5.0 mode.
  • Commandline interface: Remove obsolete --formal option.
  • Commandline interface: Rename the --julia option to --yul.
  • Commandline interface: Require - if standard input is used as source.
  • Compiler interface: Disallow remappings with empty prefix.
  • Control Flow Analyzer: Consider mappings as well when checking for uninitialized return values.
  • Control Flow Analyzer: Turn warning about returning uninitialized storage pointers into an error.
  • General: continue in a do...while loop jumps to the condition (it used to jump to the loop body). Warning: this may silently change the semantics of existing code.
  • General: Disallow declaring empty structs.
  • General: Disallow raw callcode (was already deprecated in 0.4.12). It is still possible to use it via inline assembly.
  • General: Disallow var keyword.
  • General: Disallow sha3 and suicide aliases.
  • General: Disallow the throw statement. This was already the case in the experimental 0.5.0 mode.
  • General: Disallow the years unit denomination (was already deprecated in 0.4.24)
  • General: Introduce emit as a keyword instead of parsing it as identifier.
  • General: New keywords: calldata and constructor
  • General: New reserved keywords: alias, apply, auto, copyof, define, immutable, implements, macro, mutable, override, partial, promise, reference, sealed, sizeof, supports, typedef and unchecked.
  • General: Remove assembly instruction aliases sha3 and suicide
  • General: C99-style scoping rules are enforced now. This was already the case in the experimental 0.5.0 mode.
  • General: Disallow combining hex numbers with unit denominations (e.g. 0x1e wei). This was already the case in the experimental 0.5.0 mode.
  • JSON AST: Remove constant and payable fields (the information is encoded in the stateMutability field).
  • Interface: Remove "clone contract" feature. The --clone-bin and --combined-json clone-bin commandline options are not available anymore.
  • Name Resolver: Do not exclude public state variables when looking for conflicting declarations.
  • Optimizer: Remove the no-op PUSH1 0 NOT AND sequence.
  • Parser: Disallow trailing dots that are not followed by a number.
  • Parser: Remove constant as function state mutability modifier.
  • Parser: Disallow uppercase X in hex number literals
  • Type Checker: Disallow assignments between tuples with different numbers of components. This was already the case in the experimental 0.5.0 mode.
  • Type Checker: Disallow values for constants that are not compile-time constants. This was already the case in the experimental 0.5.0 mode.
  • Type Checker: Disallow arithmetic operations for boolean variables.
  • Type Checker: Disallow tight packing of literals. This was already the case in the experimental 0.5.0 mode.
  • Type Checker: Disallow calling base constructors without parentheses. This was already the case in the experimental 0.5.0 mode.
  • Type Checker: Disallow conversions between bytesX and uintY of different size.
  • Type Checker: Disallow conversions between unrelated contract types. Explicit conversion via address can still achieve it.
  • Type Checker: Disallow empty return statements for functions with one or more return values.
  • Type Checker: Disallow empty tuple components. This was partly already the case in the experimental 0.5.0 mode.
  • Type Checker: Disallow multi-variable declarations with mismatching number of values. This was already the case in the experimental 0.5.0 mode.
  • Type Checker: Disallow specifying base constructor arguments multiple times in the same inheritance hierarchy. This was already the case in the experimental 0.5.0 mode.
  • Type Checker: Disallow calling constructor with wrong argument count. This was already the case in the experimental 0.5.0 mode.
  • Type Checker: Disallow uninitialized storage variables. This was already the case in the experimental 0.5.0 mode.
  • Type Checker: Detecting cyclic dependencies in variables and structs is limited in recursion to 256.
  • Type Checker: Require explicit data location for all variables, including function parameters. This was partly already the case in the experimental 0.5.0 mode.
  • Type Checker: Only accept a single bytes type for .call() (and family), keccak256(), sha256() and ripemd160().
  • Type Checker: Fallback function must be external. This was already the case in the experimental 0.5.0 mode.
  • Type Checker: Interface functions must be declared external. This was already the case in the experimental 0.5.0 mode.
  • Type Checker: Address members are not included in contract types anymore. An explicit conversion is now required before invoking an address member from a contract.
  • Type Checker: Disallow "loose assembly" syntax entirely. This means that jump labels, jumps and non-functional instructions cannot be used anymore.
  • Type System: Disallow explicit and implicit conversions from decimal literals to bytesXX types.
  • Type System: Disallow explicit and implicit conversions from hex literals to bytesXX types of different size.
  • Type System: Distinguish between payable and non-payable address types.
  • View Pure Checker: Disallow msg.value in (or introducing it via a modifier to) a non-payable function.
  • Remove obsolete std directory from the Solidity repository. This means accessing https://github.com/ethereum/solidity/blob/develop/std/*.sol (or https://github.com/ethereum/solidity/std/*.sol in Remix) will not be possible.
  • References Resolver: Turn missing storage locations into an error. This was already the case in the experimental 0.5.0 mode.
  • Syntax Checker: Disallow functions without implementation to use modifiers. This was already the case in the experimental 0.5.0 mode.
  • Syntax Checker: Named return values in function types are an error.
  • Syntax Checker: Strictly require visibility specifier for functions. This was already the case in the experimental 0.5.0 mode.
  • Syntax Checker: Disallow unary +. This was already the case in the experimental 0.5.0 mode.
  • Syntax Checker: Disallow single statement variable declaration inside if/while/for bodies that are not blocks.
  • View Pure Checker: Strictly enforce state mutability. This was already the case in the experimental 0.5.0 mode.

Language Features:

  • General: Add staticcall to address.
  • General: Allow appending calldata keyword to types, to explicitly specify data location for arguments of external functions.
  • General: Support pop() for storage arrays.
  • General: Scoping rules now follow the C99-style.
  • General: Allow enums in interfaces.
  • General: Allow mapping storage pointers as arguments and return values in all internal functions.
  • General: Allow structs in interfaces.
  • General: Provide access to the ABI decoder through abi.decode(bytes memory data, (...)).
  • General: Disallow zero length for fixed-size arrays.
  • Parser: Accept the address payable type during parsing.

Compiler Features:

  • Build System: Support for Mojave version of macOS added.
  • C API (libsolc): Export the solidity_license, solidity_version and solidity_compile methods.
  • Code Generator: CREATE2 instruction has been updated to match EIP1014 (aka "Skinny CREATE2"). It also is accepted as part of Constantinople.
  • Code Generator: EXTCODEHASH instruction has been added based on EIP1052.
  • Type Checker: Nicer error message when trying to reference overloaded identifiers in inline assembly.
  • Type Checker: Show named argument in case of error.
  • Type System: IntegerType is split into IntegerType and AddressType internally.
  • Tests: Determine transaction status during IPC calls.
  • Code Generator: Allocate and free local variables according to their scope.
  • Removed pragma experimental "v0.5.0";.

Bugfixes:

  • Build System: Support versions of CVC4 linked against CLN instead of GMP. In case of compilation issues due to the experimental SMT solver support, the solvers can be disabled when configuring the project with CMake using -DUSE_CVC4=OFF or -DUSE_Z3=OFF.
  • Tests: Fix chain parameters to make ipc tests work with newer versions of cpp-ethereum.
  • Code Generator: Fix allocation of byte arrays (zeroed out too much memory).
  • Code Generator: Properly handle negative number literals in ABIEncoderV2.
  • Code Generator: Do not crash on using a length of zero for multidimensional fixed-size arrays.
  • Commandline Interface: Correctly handle paths with backslashes on windows.
  • Fix NatSpec json output for @notice and @dev tags on contract definitions.
  • Optimizer: Correctly estimate gas costs of constants for special cases.
  • Optimizer: Fix simplification rule initialization bug that appeared on some emscripten platforms.
  • References Resolver: Do not crash on using _slot and _offset suffixes on their own.
  • References Resolver: Enforce storage as data location for mappings.
  • References Resolver: Properly handle invalid references used together with _slot and _offset.
  • References Resolver: Report error instead of assertion fail when FunctionType has an undeclared type as parameter.
  • References Resolver: Fix high CPU usage when using large variable names issue. Only suggest similar name if identifiers shorter than 80 characters.
  • Type Checker: Default data location for type conversions (e.g. from literals) is memory and not storage.
  • Type Checker: Disallow assignments to mappings within tuple assignments as well.
  • Type Checker: Disallow packed encoding of arrays of structs.
  • Type Checker: Allow assignments to local variables of mapping types.
  • Type Checker: Consider fixed size arrays when checking for recursive structs.
  • Type Checker: Fix crashes in erroneous tuple assignments in which the type of the right hand side cannot be determined.
  • Type Checker: Fix freeze for negative fixed-point literals very close to 0, such as -1e-100.
  • Type Checker: Dynamic types as key for public mappings return error instead of assertion fail.
  • Type Checker: Fix internal error when array index value is too large.
  • Type Checker: Fix internal error for array type conversions.
  • Type System: Allow arbitrary exponents for literals with a mantissa of zero.
  • Parser: Fix incorrect source location for nameless parameters.

0.4.25 (2018-09-12)

Important Bugfixes:

  • Code Generator: Properly perform cleanup for exponentiation and non-256 bit types.
  • Type Checker: Report error when using indexed structs in events with experimental ABIEncoderV2. This used to log wrong values.
  • Type Checker: Report error when using structs in events without experimental ABIEncoderV2. This used to crash or log the wrong values.
  • Parser: Consider all unicode line terminators (LF, VF, FF, CR, NEL, LS, PS) for single-line comments and string literals. They are invalid in strings and will end comments.
  • Parser: Disallow unterminated multi-line comments at the end of input.
  • Parser: Treat /** / as unterminated multi-line comment.

0.4.24 (2018-05-16)

Language Features:

  • Code Generator: Use native shift instructions on target Constantinople.
  • General: Allow multiple variables to be declared as part of a tuple assignment, e.g. (uint a, uint b) = ....
  • General: Remove deprecated constant as function state modifier from documentation and tests (but still leave it as a valid feature).
  • Type Checker: Deprecate the years unit denomination and raise a warning for it (or an error as experimental 0.5.0 feature).
  • Type Checker: Make literals (without explicit type casting) an error for tight packing as experimental 0.5.0 feature.
  • Type Checker: Warn about wildcard tuple assignments (this will turn into an error with version 0.5.0).
  • Type Checker: Warn when keccak256, sha256 and ripemd160 are not used with a single bytes argument (suggest to use abi.encodePacked(...)). This will turn into an error with version 0.5.0.

Compiler Features:

  • Build System: Update internal dependency of jsoncpp to 1.8.4, which introduces more strictness and reduces memory usage.
  • Control Flow Graph: Add Control Flow Graph as analysis structure.
  • Control Flow Graph: Warn about returning uninitialized storage pointers.
  • Gas Estimator: Only explore paths with higher gas costs. This reduces accuracy but greatly improves the speed of gas estimation.
  • Optimizer: Remove unnecessary masking of the result of known short instructions (ADDRESS, CALLER, ORIGIN and COINBASE).
  • Parser: Display nicer error messages by showing the actual tokens and not internal names.
  • Parser: Use the entire location of the token instead of only its starting position as source location for parser errors.
  • SMT Checker: Support state variables of integer and bool type.

Bugfixes:

  • Code Generator: Fix revert with reason coming from a state or local string variable.
  • Type Checker: Show proper error when trying to emit a non-event.
  • Type Checker: Warn about empty tuple components (this will turn into an error with version 0.5.0).
  • Type Checker: The ABI encoding functions are pure and thus can be used for constants.

0.4.23 (2018-04-19)

Features:

  • Build system: Support Ubuntu Bionic.
  • SMTChecker: Integration with CVC4 SMT solver
  • Syntax Checker: Warn about functions named "constructor".

Bugfixes:

  • Type Checker: Improve error message for failed function overload resolution.
  • Type Checker: Do not complain about new-style constructor and fallback function to have the same name.
  • Type Checker: Detect multiple constructor declarations in the new syntax and old syntax.
  • Type Checker: Explicit conversion of bytesXX to contract is properly disallowed.

0.4.22 (2018-04-16)

Features:

  • Code Generator: Initialize arrays without using msize().
  • Code Generator: More specialized and thus optimized implementation for x.push(...)
  • Commandline interface: Error when missing or inaccessible file detected. Suppress it with the --ignore-missing flag.
  • Constant Evaluator: Fix evaluation of single element tuples.
  • General: Add encoding routines abi.encodePacked, abi.encode, abi.encodeWithSelector and abi.encodeWithSignature.
  • General: Add global function gasleft() and deprecate msg.gas.
  • General: Add global function blockhash(uint) and deprecate block.hash(uint).
  • General: Allow providing reason string for revert() and require().
  • General: Introduce new constructor syntax using the constructor keyword as experimental 0.5.0 feature.
  • General: Limit the number of errors output in a single run to 256.
  • General: Support accessing dynamic return data in post-byzantium EVMs.
  • General: Allow underscores in numeric and hex literals to separate thousands and quads.
  • Inheritance: Error when using empty parentheses for base class constructors that require arguments as experimental 0.5.0 feature.
  • Inheritance: Error when using no parentheses in modifier-style constructor calls as experimental 0.5.0 feature.
  • Interfaces: Allow overriding external functions in interfaces with public in an implementing contract.
  • Optimizer: Optimize SHL and SHR only involving constants (Constantinople only).
  • Optimizer: Remove useless SWAP1 instruction preceding a commutative instruction (such as ADD, MUL, etc).
  • Optimizer: Replace comparison operators (LT, GT, etc) with opposites if preceded by SWAP1, e.g. SWAP1 LT is replaced with GT.
  • Optimizer: Optimize across mload if msize() is not used.
  • Static Analyzer: Error on duplicated super constructor calls as experimental 0.5.0 feature.
  • Syntax Checker: Issue warning for empty structs (or error as experimental 0.5.0 feature).
  • Syntax Checker: Warn about modifiers on functions without implementation (this will turn into an error with version 0.5.0).
  • Syntax Tests: Add source locations to syntax test expectations.
  • Type Checker: Improve documentation and warnings for accessing contract members inherited from address.

Bugfixes:

  • Code Generator: Allow block.blockhash without being called.
  • Code Generator: Do not include internal functions in the runtime bytecode which are only referenced in the constructor.
  • Code Generator: Properly skip unneeded storage array cleanup when not reducing length.
  • Code Generator: Bugfix in modifier lookup in libraries.
  • Code Generator: Implement packed encoding of external function types.
  • Code Generator: Treat empty base constructor argument list as not provided.
  • Code Generator: Properly force-clean bytesXX types for shortening conversions.
  • Commandline interface: Fix error messages for imported files that do not exist.
  • Commandline interface: Support --evm-version constantinople properly.
  • DocString Parser: Fix error message for empty descriptions.
  • Gas Estimator: Correctly ignore costs of fallback function for other functions.
  • JSON AST: Remove storage qualifier for type name strings.
  • Parser: Fix internal compiler error when parsing var declaration without identifier.
  • Parser: Fix parsing of getters for function type variables.
  • Standard JSON: Support constantinople as evmVersion properly.
  • Static Analyzer: Fix non-deterministic order of unused variable warnings.
  • Static Analyzer: Invalid arithmetic with constant expressions causes errors.
  • Type Checker: Fix detection of recursive structs.
  • Type Checker: Fix asymmetry bug when comparing with literal numbers.
  • Type System: Improve error message when attempting to shift by a fractional amount.
  • Type System: Make external library functions accessible.
  • Type System: Prevent encoding of weird types.
  • Type System: Restrict rational numbers to 4096 bits.

0.4.21 (2018-03-07)

Features:

  • Code Generator: Assert that k != 0 for mulmod(a, b, k) and addmod(a, b, k) as experimental 0.5.0 feature.
  • Code Generator: Do not retain any gas in calls (except if EVM version is set to homestead).
  • Code Generator: Use STATICCALL opcode for calling view and pure functions as experimental 0.5.0 feature.
  • General: C99/C++-style scoping rules (instead of JavaScript function scoping) take effect as experimental v0.5.0 feature.
  • General: Improved messaging when error spans multiple lines of a sourcefile
  • General: Support and recommend using emit EventName(); to call events explicitly.
  • Inline Assembly: Enforce strict mode as experimental 0.5.0 feature.
  • Interface: Provide ability to select target EVM version (homestead or byzantium, with byzantium being the default).
  • Standard JSON: Reject badly formatted invalid JSON inputs.
  • Type Checker: Disallow uninitialized storage pointers as experimental 0.5.0 feature.
  • Syntax Analyser: Do not warn about experimental features if they do not concern code generation.
  • Syntax Analyser: Do not warn about pragma experimental "v0.5.0" and do not set the experimental flag in the bytecode for this.
  • Syntax Checker: Mark throw as an error as experimental 0.5.0 feature.
  • Syntax Checker: Issue error if no visibility is specified on contract functions as experimental 0.5.0 feature.
  • Syntax Checker: Issue warning when using overloads of address on contract instances.
  • Type Checker: disallow combining hex numbers and unit denominations as experimental 0.5.0 feature.

Bugfixes:

  • Assembly: Raise error on oversized number literals in assembly.
  • JSON-AST: Add "documentation" property to function, event and modifier definition.
  • Resolver: Properly determine shadowing for imports with aliases.
  • Standalone Assembly: Do not ignore input after closing brace of top level block.
  • Standard JSON: Catch errors properly when invalid "sources" are passed.
  • Standard JSON: Ensure that library addresses supplied are of correct length and hex prefixed.
  • Type Checker: Properly detect which array and struct types are unsupported by the old ABI encoder.
  • Type Checker: Properly warn when using _offset and _slot for constants in inline assembly.
  • Commandline interface: throw error if option is unknown

0.4.20 (2018-02-14)

Features:

  • Code Generator: Prevent non-view functions in libraries from being called directly (as opposed to via delegatecall).
  • Commandline interface: Support strict mode of assembly (disallowing jumps, instructional opcodes, etc) with the --strict-assembly switch.
  • Inline Assembly: Issue warning for using jump labels (already existed for jump instructions).
  • Inline Assembly: Support some restricted tokens (return, byte, address) as identifiers in Iulia mode.
  • Optimiser: Replace x % 2**i by x & (2**i-1).
  • Resolver: Continue resolving references after the first error.
  • Resolver: Suggest alternative identifiers if a given identifier is not found.
  • SMT Checker: Take if-else branch conditions into account in the SMT encoding of the program variables.
  • Syntax Checker: Deprecate the var keyword (and mark it an error as experimental 0.5.0 feature).
  • Type Checker: Allow this.f.selector to be a pure expression.
  • Type Checker: Issue warning for using public visibility for interface functions.
  • Type Checker: Limit the number of warnings raised for creating abstract contracts.

Bugfixes:

  • Error Output: Truncate huge number literals in the middle to avoid output blow-up.
  • Parser: Disallow event declarations with no parameter list.
  • Standard JSON: Populate the sourceLocation field in the error list.
  • Standard JSON: Properly support contract and library file names containing a colon (such as URLs).
  • Type Checker: Suggest the experimental ABI encoder if using structs as function parameters (instead of an internal compiler error).
  • Type Checker: Improve error message for wrong struct initialization.

0.4.19 (2017-11-30)

Features:

  • Code Generator: New ABI decoder which supports structs and arbitrarily nested arrays and checks input size (activate using pragma experimental ABIEncoderV2;).
  • General: Allow constant variables to be used as array length.
  • Inline Assembly: if statement.
  • Standard JSON: Support the outputSelection field for selective compilation of target artifacts.
  • Syntax Checker: Turn the usage of callcode into an error as experimental 0.5.0 feature.
  • Type Checker: Improve address checksum warning.
  • Type Checker: More detailed errors for invalid array lengths (such as division by zero).

Bugfixes:

0.4.18 (2017-10-18)

Features:

  • Code Generator: Always use all available gas for calls as experimental 0.5.0 feature (previously, some amount was retained in order to work in pre-Tangerine-Whistle EVM versions)
  • Parser: Better error message for unexpected trailing comma in parameter lists.
  • Standard JSON: Support the outputSelection field for selective compilation of supplied sources.
  • Syntax Checker: Unary + is now a syntax error as experimental 0.5.0 feature.
  • Type Checker: Disallow non-pure constant state variables as experimental 0.5.0 feature.
  • Type Checker: Do not add members of address to contracts as experimental 0.5.0 feature.
  • Type Checker: Force interface functions to be external as experimental 0.5.0 feature.
  • Type Checker: Require storage or memory keyword for local variables as experimental 0.5.0 feature.
  • Compiler Interface: Better formatted error message for long source snippets

Bugfixes:

  • Code Generator: Allocate one byte per memory byte array element instead of 32.
  • Code Generator: Do not accept data with less than four bytes (truncated function signature) for regular function calls - fallback function is invoked instead.
  • Optimizer: Remove unused stack computation results.
  • Parser: Fix source location of VariableDeclarationStatement.
  • Type Checker: Allow gas in view functions.
  • Type Checker: Do not mark event parameters as shadowing state variables.
  • Type Checker: Prevent duplicate event declarations.
  • Type Checker: Properly check array length and don't rely on an assertion in code generation.
  • Type Checker: Properly support overwriting members inherited from address in a contract (such as balance, transfer, etc.)
  • Type Checker: Validate each number literal in tuple expressions even if they are not assigned from.

0.4.17 (2017-09-21)

Features:

  • Assembly Parser: Support multiple assignment (x, y := f()).
  • Code Generator: Keep a single copy of encoding functions when using the experimental "ABIEncoderV2".
  • Code Generator: Partial support for passing structs as arguments and return parameters (requires pragma experimental ABIEncoderV2; for now).
  • General: Support pragma experimental "v0.5.0"; to activate upcoming breaking changes.
  • General: Added .selector member on external function types to retrieve their signature.
  • Optimizer: Add new optimization step to remove unused JUMPDESTs.
  • Static Analyzer: Warn when using deprecated builtins sha3 and suicide (replaced by keccak256 and selfdestruct, introduced in 0.4.2 and 0.2.0, respectively).
  • Syntax Checker: Warn if no visibility is specified on contract functions.
  • Type Checker: Display helpful warning for unused function arguments/return parameters.
  • Type Checker: Do not show the same error multiple times for events.
  • Type Checker: Greatly reduce the number of duplicate errors shown for duplicate constructors and functions.
  • Type Checker: Warn on using literals as tight packing parameters in keccak256, sha3, sha256 and ripemd160.
  • Type Checker: Enforce view and pure.
  • Type Checker: Enforce view / constant with error as experimental 0.5.0 feature.
  • Type Checker: Enforce fallback functions to be external as experimental 0.5.0 feature.

Bugfixes:

  • ABI JSON: Include all overloaded events.
  • Parser: Crash fix related to parseTypeName.
  • Type Checker: Allow constant byte arrays.

0.4.16 (2017-08-24)

Features:

  • ABI JSON: Include new field stateMutability with values pure, view, nonpayable and payable.
  • Analyzer: Experimental partial support for Z3 SMT checker ("SMTChecker").
  • Build System: Shared libraries (libdevcore, libevmasm, libsolidity and liblll) are no longer produced during the build process.
  • Code generator: Experimental new implementation of ABI encoder that can encode arbitrarily nested arrays ("ABIEncoderV2")
  • Metadata: Store experimental flag in metadata CBOR.
  • Parser: Display previous visibility specifier in error if multiple are found.
  • Parser: Introduce pure and view keyword for functions, constant remains an alias for view and pureness is not enforced yet, so use with care.
  • Static Analyzer: Warn about large storage structures.
  • Syntax Checker: Support pragma experimental <feature>; to turn on experimental features.
  • Type Checker: More detailed error message for invalid overrides.
  • Type Checker: Warn about shifting a literal.

Bugfixes:

  • Assembly Parser: Be more strict about number literals.
  • Assembly Parser: Limit maximum recursion depth.
  • Parser: Enforce commas between array and tuple elements.
  • Parser: Limit maximum recursion depth.
  • Type Checker: Crash fix related to using.
  • Type Checker: Disallow constructors in libraries.
  • Type Checker: Reject the creation of interface contracts using the new statement.

0.4.15 (2017-08-08)

Features:

  • Type Checker: Show unimplemented function if trying to instantiate an abstract class.

Bugfixes:

  • Code Generator: .delegatecall() should always return execution outcome.
  • Code Generator: Provide "new account gas" for low-level callcode and delegatecall.
  • Type Checker: Constructors must be implemented if declared.
  • Type Checker: Disallow the .gas() modifier on ecrecover, sha256 and ripemd160.
  • Type Checker: Do not mark overloaded functions as shadowing other functions.
  • Type Checker: Internal library functions must be implemented if declared.

0.4.14 (2017-07-31)

Features:

  • C API (jsonCompiler): Export the license method.
  • Code Generator: Optimise the fallback function, by removing a useless jump.
  • Inline Assembly: Show useful error message if trying to access calldata variables.
  • Inline Assembly: Support variable declaration without initial value (defaults to 0).
  • Metadata: Only include files which were used to compile the given contract.
  • Type Checker: Disallow value transfers to contracts without a payable fallback function.
  • Type Checker: Include types in explicit conversion error message.
  • Type Checker: Raise proper error for arrays too large for ABI encoding.
  • Type checker: Warn if using this in a constructor.
  • Type checker: Warn when existing symbols, including builtins, are overwritten.

Bugfixes:

  • Code Generator: Properly clear return memory area for ecrecover.
  • Type Checker: Fix crash for some assignment to non-lvalue.
  • Type Checker: Fix invalid "specify storage keyword" warning for reference members of structs.
  • Type Checker: Mark modifiers as internal.
  • Type Checker: Re-allow multiple mentions of the same modifier per function.

0.4.13 (2017-07-06)

Features:

  • Syntax Checker: Deprecated "throw" in favour of require(), assert() and revert().
  • Type Checker: Warn if a local storage reference variable does not explicitly use the keyword storage.

Bugfixes:

  • Code Generator: Correctly unregister modifier variables.
  • Compiler Interface: Only output AST if analysis was successful.
  • Error Output: Do not omit the error type.

0.4.12 (2017-07-03)

Features:

  • Assembly: Add CREATE2 (EIP86), STATICCALL (EIP214), RETURNDATASIZE and RETURNDATACOPY (EIP211) instructions.
  • Assembly: Display auxiliary data in the assembly output.
  • Assembly: Renamed SHA3 to KECCAK256.
  • AST: export all attributes to JSON format.
  • C API (jsonCompiler): Use the Standard JSON I/O internally.
  • Code Generator: Added the Whiskers template system.
  • Inline Assembly: for and switch statements.
  • Inline Assembly: Function definitions and function calls.
  • Inline Assembly: Introduce keccak256 as an opcode. sha3 is still a valid alias.
  • Inline Assembly: Present proper error message when not supplying enough arguments to a functional instruction.
  • Inline Assembly: Warn when instructions shadow Solidity variables.
  • Inline Assembly: Warn when using jumps.
  • Remove obsolete Why3 output.
  • Type Checker: Enforce strict UTF-8 validation.
  • Type Checker: Warn about copies in storage that might overwrite unexpectedly.
  • Type Checker: Warn about type inference from literal numbers.
  • Static Analyzer: Warn about deprecation of callcode.

Bugfixes:

  • Assembly: mark MLOAD to have side effects in the optimiser.
  • Code Generator: Fix ABI encoding of empty literal string.
  • Code Generator: Fix negative stack size checks.
  • Code generator: Use REVERT instead of INVALID for generated input validation routines.
  • Inline Assembly: Enforce function arguments when parsing functional instructions.
  • Optimizer: Disallow optimizations involving MLOAD because it changes MSIZE.
  • Static Analyzer: Unused variable warnings no longer issued for variables used inside inline assembly.
  • Type Checker: Fix address literals not being treated as compile-time constants.
  • Type Checker: Fixed crash concerning non-callable types.
  • Type Checker: Fixed segfault with constant function parameters
  • Type Checker: Disallow comparisons between mapping and non-internal function types.
  • Type Checker: Disallow invoking the same modifier multiple times.
  • Type Checker: Do not treat strings that look like addresses as addresses.
  • Type Checker: Support valid, but incorrectly rejected UTF-8 sequences.

0.4.11 (2017-05-03)

Features:

  • Implement the Standard JSON Input / Output API
  • Support interface contracts.
  • C API (jsonCompiler): Add the compileStandard() method to process a Standard JSON I/O.
  • Commandline interface: Add the --standard-json parameter to process a Standard JSON I/O.
  • Commandline interface: Support --allow-paths to define trusted import paths. Note: the path(s) of the supplied source file(s) is always trusted.
  • Inline Assembly: Storage variable access using _slot and _offset suffixes.
  • Inline Assembly: Disallow blocks with unbalanced stack.
  • Static analyzer: Warn about statements without effects.
  • Static analyzer: Warn about unused local variables, parameters, and return parameters.
  • Syntax checker: issue deprecation warning for unary '+'

Bugfixes:

  • Assembly output: Implement missing AssemblyItem types.
  • Compiler interface: Fix a bug where source indexes could be inconsistent between Solidity compiled with different compilers (clang vs. gcc) or compiler settings. The bug was visible in AST and source mappings.
  • Gas Estimator: Reflect the most recent fee schedule.
  • Type system: Contract inheriting from base with unimplemented constructor should be abstract.
  • Optimizer: Number representation bug in the constant optimizer fixed.

0.4.10 (2017-03-15)

Features:

  • Add assert(condition), which throws if condition is false (meant for internal errors).
  • Add require(condition), which throws if condition is false (meant for invalid input).
  • Commandline interface: Do not overwrite files unless forced.
  • Introduce .transfer(value) for sending Ether.
  • Code generator: Support revert() to abort with rolling back, but not consuming all gas.
  • Inline assembly: Support revert (EIP140) as an opcode.
  • Parser: Support scientific notation in numbers (e.g. 2e8 and 200e-2).
  • Type system: Support explicit conversion of external function to address.
  • Type system: Warn if base of exponentiation is literal (result type might be unexpected).
  • Type system: Warn if constant state variables are not compile-time constants.

Bugfixes:

  • Commandline interface: Always escape filenames (replace /, : and . with _).
  • Commandline interface: Do not try creating paths . and ...
  • Commandline interface: Allow long library names.
  • Parser: Disallow octal literals.
  • Type system: Fix a crash caused by continuing on fatal errors in the code.
  • Type system: Disallow compound assignment for tuples.
  • Type system: Detect cyclic dependencies between constants.
  • Type system: Disallow arrays with negative length.
  • Type system: Fix a crash related to invalid binary operators.
  • Type system: Disallow var declaration with empty tuple type.
  • Type system: Correctly convert function argument types to pointers for member functions.
  • Type system: Move privateness of constructor into AST itself.
  • Inline assembly: Charge one stack slot for non-value types during analysis.
  • Assembly output: Print source location before the operation it refers to instead of after.
  • Optimizer: Stop trying to optimize tricky constants after a while.

0.4.9 (2017-01-31)

Features:

  • Compiler interface: Contracts and libraries can be referenced with a file: prefix to make them unique.
  • Compiler interface: Report source location for "stack too deep" errors.
  • AST: Use deterministic node identifiers.
  • Inline assembly: introduce invalid (EIP141) as an opcode.
  • Type system: Introduce type identifier strings.
  • Type checker: Warn about invalid checksum for addresses and deduce type from valid ones.
  • Metadata: Do not include platform in the version number.
  • Metadata: Add option to store sources as literal content.
  • Code generator: Extract array utils into low-level functions.
  • Code generator: Internal errors (array out of bounds, etc.) now cause a reversion by using an invalid instruction (0xfe - EIP141) instead of an invalid jump. Invalid jump is still kept for explicit throws.

Bugfixes:

  • Code generator: Allow recursive structs.
  • Inline assembly: Disallow variables named like opcodes.
  • Type checker: Allow multiple events of the same name (but with different arities or argument types)
  • Natspec parser: Fix error with @param parsing and whitespace.

0.4.8 (2017-01-13)

Features:

  • Optimiser: Performance improvements.
  • Output: Print assembly in new standardized Solidity assembly format.

Bugfixes:

  • Remappings: Prefer longer context over longer prefix.
  • Type checker, code generator: enable access to events of base contracts' names.
  • Imports: import ".dir/a" is not a relative path. Relative paths begin with directory . or ...
  • Type checker, disallow inheritances of different kinds (e.g. a function and a modifier) of members of the same name

0.4.7 (2016-12-15)

Features:

  • Bitshift operators.
  • Type checker: Warn when msg.value is used in non-payable function.
  • Code generator: Inject the Swarm hash of a metadata file into the bytecode.
  • Code generator: Replace expensive memcpy precompile by simple assembly loop.
  • Optimizer: Some dead code elimination.

Bugfixes:

  • Code generator: throw if calling the identity precompile failed during memory (array) copying.
  • Type checker: string literals that are not valid UTF-8 cannot be converted to string type
  • Code generator: any non-zero value given as a boolean argument is now converted into 1.
  • AST Json Converter: replace VariableDefinitionStatement nodes with VariableDeclarationStatement
  • AST Json Converter: fix the camel case in ElementaryTypeNameExpression
  • AST Json Converter: replace public field with visibility in the function definition nodes

0.4.6 (2016-11-22)

Bugfixes:

  • Optimizer: Knowledge about state was not correctly cleared for JUMPDESTs (introduced in 0.4.5)

0.4.5 (2016-11-21)

Features:

  • Function types
  • Do-while loops: support for a do <block> while (<expr>); control structure
  • Inline assembly: support invalidJumpLabel as a jump label.
  • Type checker: now more eagerly searches for a common type of an inline array with mixed types
  • Code generator: generates a runtime error when an out-of-range value is converted into an enum type.

Bugfixes:

  • Inline assembly: calculate stack height warning correctly even when local variables are used.
  • Code generator: check for value transfer in non-payable constructors.
  • Parser: disallow empty enum definitions.
  • Type checker: disallow conversion between different enum types.
  • Interface JSON: do not include trailing new line.

0.4.4 (2016-10-31)

Bugfixes:

  • Type checker: forbid signed exponential that led to an incorrect use of EXP opcode.
  • Code generator: properly clean higher order bytes before storing in storage.

0.4.3 (2016-10-25)

Features:

  • Inline assembly: support both suicide and selfdestruct opcodes (note: suicide is deprecated).
  • Inline assembly: issue warning if stack is not balanced after block.
  • Include keccak256() as an alias to sha3().
  • Support shifting constant numbers.

Bugfixes:

  • Commandline interface: Disallow unknown options in solc.
  • Name resolver: Allow inheritance of enum definitions.
  • Type checker: Proper type checking for bound functions.
  • Type checker: fixed crash related to invalid fixed point constants
  • Type checker: fixed crash related to invalid literal numbers.
  • Type checker: super.x does not look up x in the current contract.
  • Code generator: expect zero stack increase after super as an expression.
  • Code generator: fix an internal compiler error for L.Foo for enum Foo defined in library L.
  • Code generator: allow inheritance of enum definitions.
  • Inline assembly: support the address opcode.
  • Inline assembly: fix parsing of assignment after a label.
  • Inline assembly: external variables of unsupported type (such as this, super, etc.) are properly detected as unusable.
  • Inline assembly: support variables within modifiers.
  • Optimizer: fix related to stale knowledge about SHA3 operations

0.4.2 (2016-09-17)

Bugfixes:

  • Code Generator: Fix library functions being called from payable functions.
  • Type Checker: Fixed a crash about invalid array types.
  • Code Generator: Fixed a call gas bug that became visible after version 0.4.0 for calls where the output is larger than the input.

0.4.1 (2016-09-09)

  • Build System: Fixes to allow library compilation.

0.4.0 (2016-09-08)

This release deliberately breaks backwards compatibility mostly to enforce some safety features. The most important change is that you have to explicitly specify if functions can receive ether via the payable modifier. Furthermore, more situations cause exceptions to be thrown.

Minimal changes to be made for upgrade:

  • Add payable to all functions that want to receive Ether (including the constructor and the fallback function).
  • Change _ to _; in modifiers.
  • Add version pragma to each file: pragma solidity ^0.4.0;

Breaking Changes:

  • Source files have to specify the compiler version they are compatible with using e.g. pragma solidity ^0.4.0; or pragma solidity >=0.4.0 <0.4.8;
  • Functions that want to receive Ether have to specify the new payable modifier (otherwise they throw).
  • Contracts that want to receive Ether with a plain "send" have to implement a fallback function with the payable modifier. Contracts now throw if no payable fallback function is defined and no function matches the signature.
  • Failing contract creation through "new" throws.
  • Division / modulus by zero throws.
  • Function call throws if target contract does not have code
  • Modifiers are required to contain _ (use if (false) _ as a workaround if needed).
  • Modifiers: return does not skip part in modifier after _.
  • Placeholder statement _ in modifier now requires explicit ;.
  • ecrecover now returns zero if the input is malformed (it previously returned garbage).
  • The constant keyword cannot be used for constructors or the fallback function.
  • Removed --interface (Solidity interface) output option
  • JSON AST: General cleanup, renamed many nodes to match their C++ names.
  • JSON output: srcmap-runtime renamed to srcmapRuntime.
  • Moved (and reworked) standard library contracts from inside the compiler to github.com/ethereum/solidity/std (import "std"; or import owned; do not work anymore).
  • Confusing and undocumented keyword after was removed.
  • New reserved words: abstract, hex, interface, payable, pure, static, view.

Features:

  • Hexadecimal string literals: hex"ab1248fe"
  • Internal: Inline assembly usable by the code generator.
  • Commandline interface: Using - as filename allows reading from stdin.
  • Interface JSON: Fallback function is now part of the ABI.
  • Interface: Version string now semver compatible.
  • Code generator: Do not provide "new account gas" if we know the called account exists.

Bugfixes:

  • JSON AST: Nodes were added at wrong parent
  • Why3 translator: Crash fix for exponentiation
  • Commandline Interface: linking libraries with underscores in their name.
  • Type Checker: Fallback function cannot return data anymore.
  • Code Generator: Fix crash when sha3() was used on unsupported types.
  • Code Generator: Manually set gas stipend for .send(0).

Lots of changes to the documentation mainly by voluntary external contributors.

0.3.6 (2016-08-10)

Features:

  • Formal verification: Take external effects on a contract into account.
  • Type Checker: Warning about unused return value of low-level calls and send.
  • Output: Source location and node id as part of AST output
  • Output: Source location mappings for bytecode
  • Output: Formal verification as part of json compiler output.

Bugfixes:

  • Commandline Interface: Do not crash if input is taken from stdin.
  • Scanner: Correctly support unicode escape codes in strings.
  • JSON output: Fix error about relative / absolute source file names.
  • JSON output: Fix error about invalid utf8 strings.
  • Code Generator: Dynamic allocation of empty array caused infinite loop.
  • Code Generator: Correctly calculate gas requirements for memcpy precompile.
  • Optimizer: Clear known state if two code paths are joined.

0.3.5 (2016-06-10)

Features:

  • Context-dependent path remappings (different modules can use the same library in different versions)

Bugfixes:

  • Type Checking: Dynamic return types were removed when fetching data from external calls, now they are replaced by an "unusable" type.
  • Type Checking: Overrides by constructors were considered making a function non-abstract.

0.3.4 (2016-05-31)

No change outside documentation.

0.3.3 (2016-05-27)

  • Allow internal library functions to be called (by "inlining")
  • Fractional/rational constants (only usable with fixed point types, which are still in progress)
  • Inline assembly has access to internal functions (as jump labels)
  • Running solc without arguments on a terminal will print help.
  • Bugfix: Remove some non-determinism in code generation.
  • Bugfix: Corrected usage of not / bnot / iszero in inline assembly
  • Bugfix: Correctly clean bytesNN types before comparison

0.3.2 (2016-04-18)

  • Bugfix: Inline assembly parser: byte opcode was unusable
  • Bugfix: Error reporting: tokens for variably-sized types were not converted to string properly
  • Bugfix: Dynamic arrays of structs were not deleted correctly.
  • Bugfix: Static arrays in constructor parameter list were not decoded correctly.

0.3.1 (2016-03-31)

  • Inline assembly
  • Bugfix: Code generation: array access with narrow types did not clean higher order bits
  • Bugfix: Error reporting: error reporting with unknown source location caused a crash

0.3.0 (2016-03-11)

BREAKING CHANGES:

  • Added new keywords assembly, foreign, fixed, ufixed, fixedNxM, ufixedNxM (for various values of M and N), timestamp
  • Number constant division does not round to integer, but to a fixed point type (e.g. 1 / 2 != 1, but 1 / 2 == 0.5).
  • Library calls now default to use DELEGATECALL (e.g. called library functions see the same value as the calling function for msg.value and msg.sender).
  • <address>.delegatecall as a low-level calling interface

Bugfixes:

  • Fixed a bug in the optimizer that resulted in comparisons being wrong.

0.2.2 (2016-02-17)

  • Index access for types bytes1, ..., bytes32 (only read access for now).
  • Bugfix: Type checker crash for wrong number of base constructor parameters.

0.2.1 (2016-01-30)

  • Inline arrays, i.e. var y = [1,x,f()]; if there is a common type for 1, x and f(). Note that the result is always a fixed-length memory array and conversion to dynamic-length memory arrays is not yet possible.
  • Import similar to ECMAScript6 import (import "abc.sol" as d and import {x, y} from "abc.sol").
  • Commandline compiler solc automatically resolves missing imports and allows for "include directories".
  • Conditional: x ? y : z
  • Bugfix: Fixed several bugs where the optimizer generated invalid code.
  • Bugfix: Enums and structs were not accessible to other contracts.
  • Bugfix: Fixed segfault connected to function parameter types, appeared during gas estimation.
  • Bugfix: Type checker crash for wrong number of base constructor parameters.
  • Bugfix: Allow function overloads with different array types.
  • Bugfix: Allow assignments of type (x) = 7.
  • Bugfix: Type uint176 was not available.
  • Bugfix: Fixed crash during type checking concerning constructor calls.
  • Bugfix: Fixed crash during code generation concerning invalid accessors for struct types.
  • Bugfix: Fixed crash during code generating concerning computing a hash of a struct type.

0.2.0 (2015-12-02)

  • Breaking Change: new ContractName.value(10)() has to be written as (new ContractName).value(10)()
  • Added selfdestruct as an alias for suicide.
  • Allocation of memory arrays using new.
  • Binding library functions to types via using x for y
  • addmod and mulmod (modular addition and modular multiplication with arbitrary intermediate precision)
  • Bugfix: Constructor arguments of fixed array type were not read correctly.
  • Bugfix: Memory allocation of structs containing arrays or strings.
  • Bugfix: Data location for explicit memory parameters in libraries was set to storage.

0.1.7 (2015-11-17)

  • Improved error messages for unexpected tokens.
  • Proof-of-concept transcompilation to why3 for formal verification of contracts.
  • Bugfix: Arrays (also strings) as indexed parameters of events.
  • Bugfix: Writing to elements of bytes or string overwrite others.
  • Bugfix: "Successor block not found" on Windows.
  • Bugfix: Using string literals in tuples.
  • Bugfix: Cope with invalid commit hash in version for libraries.
  • Bugfix: Some test framework fixes on windows.

0.1.6 (2015-10-16)

  • .push() for dynamic storage arrays.
  • Tuple expressions ((1,2,3) or return (1,2,3);)
  • Declaration and assignment of multiple variables (var (x,y,) = (1,2,3,4,5); or var (x,y) = f();)
  • Destructuring assignment ((x,y,) = (1,2,3))
  • Bugfix: Internal error about usage of library function with invalid types.
  • Bugfix: Correctly parse Library.structType a at statement level.
  • Bugfix: Correctly report source locations of parenthesized expressions (as part of "tuple" story).

0.1.5 (2015-10-07)

  • Breaking change in storage encoding: Encode short byte arrays and strings together with their length in storage.
  • Report warnings
  • Allow storage reference types for public library functions.
  • Access to types declared in other contracts and libraries via ..
  • Version stamp at beginning of runtime bytecode of libraries.
  • Bugfix: Problem with initialized string state variables and dynamic data in constructor.
  • Bugfix: Resolve dependencies concerning new automatically.
  • Bugfix: Allow four indexed arguments for anonymous events.
  • Bugfix: Detect too large integer constants in functions that accept arbitrary parameters.

0.1.4 (2015-09-30)

  • Bugfix: Returning fixed-size arrays.
  • Bugfix: combined-json output of solc.
  • Bugfix: Accessing fixed-size array return values.
  • Bugfix: Disallow assignment from literal strings to storage pointers.
  • Refactoring: Move type checking into its own module.

0.1.3 (2015-09-25)

  • throw statement.
  • Libraries that contain functions which are called via CALLCODE.
  • Linker stage for compiler to insert other contract's addresses (used for libraries).
  • Compiler option to output runtime part of contracts.
  • Compile-time out of bounds check for access to fixed-size arrays by integer constants.
  • Version string includes libevmasm/libethereum's version (contains the optimizer).
  • Bugfix: Accessors for constant public state variables.
  • Bugfix: Propagate exceptions in clone contracts.
  • Bugfix: Empty single-line comments are now treated properly.
  • Bugfix: Properly check the number of indexed arguments for events.
  • Bugfix: Strings in struct constructors.

0.1.2 (2015-08-20)

  • Improved commandline interface.
  • Explicit conversion between bytes and string.
  • Bugfix: Value transfer used in clone contracts.
  • Bugfix: Problem with strings as mapping keys.
  • Bugfix: Prevent usage of some operators.

0.1.1 (2015-08-04)

  • Strings can be used as mapping keys.
  • Clone contracts.
  • Mapping members are skipped for structs in memory.
  • Use only a single stack slot for storage references.
  • Improved error message for wrong argument count. (#2456)
  • Bugfix: Fix comparison between bytesXX types. (#2087)
  • Bugfix: Do not allow floats for integer literals. (#2078)
  • Bugfix: Some problem with many local variables. (#2478)
  • Bugfix: Correctly initialise string and bytes state variables.
  • Bugfix: Correctly compute gas requirements for callcode.

0.1.0 (2015-07-10)