Version 0.4.24

All remaining breaking changes planned for version 0.5.0 that can be implemented in a backwards-compatible way made it into this release. Solidity can now detect uninitialized storage pointers using control-flow analysis. It is again possible to assign multiple return values from a function to newly declared variables and the SMT checker is able to work with simple storage variables.

If you want to perform a source build, please only use solidity_0.4.24.tar.gz and not the zip provided by github directly.

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.

We especially thank all our open source community contributors:

Alexander Arlt, Andreas Olofsson, Arun Kumar, daniel, David Sanders, GuessWho, Jason Cobb, Jonny Burger, Leo Arias, Luca Ban, Magicking, Matthew Ludwig, mingchuan, nisdas, njwest, Omar Boukli-Hacene, Rafiudeen Chozhan Kumarasamy, sledrho, Wenbin Wu

Version 0.4.23

Bugfix release: In the previous release, it was possible to define two constructors (one using the new constructor-keyword syntax, another one with the old syntax) for a contract, but only one of them got used in the end. We also included other bugfixes.

If you want to perform a source build, please only use solidity_0.4.23.tar.gz and not the zip provided by github directly.

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.

We especially thank all our open source community contributors: Thomas Sauvajon

Version 0.4.22

This release features several major and long-awaited changes:

• It is now possible to access dynamic data (arrays, strings, etc) returned by function calls.
• You can specify error reason strings for revert and require (support by tooling is still pending).
• We added the global functions abi.encode(), abi.encodePacked(), abi.encodeWithSelector() and abi.encodeWithSignature() which expose the ABI encoding functions and each return a bytes value.
• Constructors should now be defined using constructor(uint arg1, uint arg2) { ... } to make them stand out and avoid bugs when contracts are renamed but not their constructors.
• Some array operations got cheaper, especially the push function and initialization of memory arrays.

If you want to perform a source build, please only use solidity_0.4.22.tar.gz and not the zip provided by github directly.

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: Allow and recommend new constructor syntax using the constructor keyword (generate error 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.
• 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.

We especially thank all our open source community contributors:

Sergiusz Bazanski, Federico Bond, Anthony Broad-Crawford, Jason Cobb, dongsamb, Robbie Ferguson, Kevin Florenzano, Grzegorz Hasse, hydai, Lefteris Karapetsas, kevinflo, NetX, Daniel R, Matías A. Ré Medina, Roman, Yosyp Schwab, wbt, Li Xuanji, Haoliang Yu

Version 0.4.21

We again introduced several changes that are scheduled for version 0.5.0 and can be activated using pragma experimental "v0.5.0";. In this release, this pragma does not generate a warning anymore, so you can (and should) use it in production code.

In addition to that, you can now specify which EVM version the contract should be compiled for. Valid values are "homestead", "tangerineWhistle", "spuriousDragon", "byzantium" (the default) and "constantinople". Depending on this setting, different opcodes will be used in some cases. The only place where this is currently used by default is that all gas is forwarded with calls starting from "tangerineWhistle" (in homestead, some gas has to be retained for the call opcode itself). Also, the gas estimator reports different costs for the opcodes depending on the version and thus the optimizer might generate different code.

The new "0.5.0" features are explained in more detail below the list of features and bugfixes.

If you want to perform a source build, please only use solidity_0.4.21.tar.gz and not the zip provided by github directly.

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 experimenal 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

We especially thank all our open source community contributors:

Alexander Arlt, Dax Bondye, Emilio Almansi, Evgeny Medvedev, Federico Bond, Hongbin Zuo, Oleksii Matiiasevych, Raghav Dua, William Entriken, bernard peh, Aaron Colaço, Alexandre Bezroutchko, Anthony Broad-Crawford, DYLAN BECKWITH, Elena Dimitrova, Furkan Ayhan, Jordi Baylina, Li Xuanji, Zhen Zhang, ankit raj, janat08, mirgj, wbt.

Details:

• Code Generator: Use STATICCALL opcode for calling view and pure functions as experimenal 0.5.0 feature.

This ensures that functions marked as view or pure (previously constant) cannot modify the state. This is especially important if you call unknown code via a generic interface and you cannot be sure whether the function modifies the state or not. This way, view and pure functions cannot have reentrancy effects.

• General: C99/C++-style scoping rules (instead of JavaScript function scoping) take effect as experimental v0.5.0 feature.

Variables are no longer valid in the whole function and even before they were declared as in JavaScript, but instead only in the {/}-enclosed block where they are declared and only starting after their declaration. These are the rules also used by C++ or Java. There is a common exception where variables declared in the initializing part of the for header are also valid in the rest of the for loop construct which we also use in Solidity. Currently, the stack slot reserved for the variable still spans the whole function, but this is planned to be improved for the next release.

• General: Support and recommend using emit EventName(); to call events explicitly.

In order to make events stand out with regards to regular function calls, emit EventName() as opposed to just EventName() should now be used to "call" events.

• Inline Assembly: Enforce strict mode as experimental 0.5.0 feature.

Strict mode disallows labels, jumps and opcodes that directly modify the stack. It is much safer than non-strict mode, since you do not have to keep track of the current state of the stack. Furthermore, it allows an optimizer stage (to be finished soon) to be created much more easily. Because of that, the optimizer will refuse to work on non-strict assembly.

• Type Checker: Disallow uninitialized storage pointers as experimental 0.5.0 feature.

Storage pointers (e.g. StructType storage x;) can lead to severe storage corruption if used without being assigned. In 0.5.0 it will be illegal to declare a storage pointer without directly initializing it.

• Syntax Checker: Mark throw as an error as experimental 0.5.0 feature.

The throw keyword creates the impression that exceptions are a feature of Solidity, while in reality, it only supports state-reversion that can soon also include error data. Because of that, throw is deprecated.

• Syntax Checker: Issue error if no visibility is specified on contract functions as experimental 0.5.0 feature.

Since there were bugs where people did not realize that the default visibility of functions is public, specifying a visibility was made mandatory.

• Syntax Checker: Issue warning when using overloads of address on contract instances.

Collisions between native members of the address type and user-defined members of contracts can easily deceive users. Because of that, address members are no longer available in contracts. If you want to use an address member (transfer is one of them!), then convert it to address: address(contractInstance).transfer(2 wei).

• Type Checker: disallow combining hex numbers and unit denominations as experimental 0.5.0 feature.

We could not think of any situation where unit denominations like seconds or ether combined with hexadecimal literals would be meaningful (0x1234 ether or 0x20 minutes) and thus deprecated this combination.

Version 0.4.20

This release includes some usability and security improvements and a further evolution of the SMT component. The var keyword has been deprecated for security reasons.

Significant steps were made in writing optimisation stages for the intermediate language, which will be used by the new ABI encoder to produce highly optimised output. The main goal is to have a resulting bytecode size similar to the old ABI encoder, while having more runtime checks for a stricter decoding process. This is not yet enabled in this release.

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.

We especially thank all our open source community contributors:

Alexander Arlt, Balajiganapathi S, ChenQuan, Chuck LeDuc Díaz, Evgeny Medvedev, Ezra Epstein, Federico Bond, Gonçalo Sá, Jim McDonald, Jimmy Vogel, Kamuela Franco, Kevin Wu, Leonardo Alt, Li Xuanji, Manus, Matthew Halpern, Maurelian, Raghav Dua, Sawyer, Steve Waldman, William Entriken, YuShuangqi, Yuriy Kashnikov, Zhen Zhang, ZoOgY-DoOgY, chenquan, Elena Dimitrova, hyperfekt, mekkanik and wbt.

If you want to perform a source build, please only use solidity_0.4.20.tar.gz and not the zip provided by github directly.

Version 0.4.19

In the last weeks, we have mainly been working on big internal changes. One of them is the new ABI decoder, which is still in experimental mode, but will hopefully be production-usable soon. External contributions like allowing constant variables for array lengths and improved error messages should make your life as a programmer easier. Finally, the standard-json-io-system now allows to select certain artifacts from a contract which should speed up your code-compile-test-cycle even more!

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).

We especially thank all our open source community contributors:

Balajiganapathi S, Boris Kostenko, Christian Pamidov, Chua Chee Wee, Ezra Epstein, Federico Bond, Francisco Giordano, Guanqun Lu, Isaac van Bakel, Jared Wasinger, Kwang Yul Seo, Liana Husikyan, Sami Mäkel Svetlin Nakov, William Morriss, rivenhk, wadeAlexC, walter-weinmann and wbt.

If you want to perform a source build, please only use solidity_0.4.19.tar.gz and not the zip provided by github directly.

Version 0.4.18

This release adds further backwards-incompatible security measures enabled via pragma experimental "v0.5.0"; and contains another important feature: You can now select to compile only certain contracts using the outputSelection field of the standard-json-io compiler interface, which should speed up tools like truffle tremendously.

There are also two important bug fixes: One was an oversight in the way bytes variables are allocated in memory and can reduce the memory requirements 32-fold. The second is a security fix: In extremely specific circumstances, it can happen that a regular function is called instead of the fallback function for an Ether transfer without data. These circumstances are: The function has to have a zero signature (one out of 4294967296), it has to be payable, the contract cannot have more than five (external) functions and it cannot have a fallback function.

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.

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.

We especially thank all our open source community contributors:

benjaminion, bernard peh, Boris Kostenko, Dave Hoover, David Au, Federico Bond, Gianfranco Cecconi, Giovanni Casinelli, Ilya Drabenia, Martín Triay, Rhett Aultman, Sergiusz Bazanski, wadeAlexC, Walter Weinmann and Zetherz.

If you want to perform a source build, please only use solidity_0.4.18.tar.gz and not the zip provided by github directly.

Version 0.4.17

As we are getting closer to the next breaking release, we want to give everyone a heads up by introducing pragma experimental "v0.5.0" which already enables some of the new safety features of the 0.5.0 release.

Furthermore, this release finally checks the modifiers view (used to be named constant) and pure on functions. As a rule of thumb, use view if your function does not modify storage and pure if it does not even read any state information - but the compiler will also suggest the tightest restriction itself.

We also worked further on the new ABI encoder: Functions can now return structs. Switch it on using pragma experimental ABIEncoderV2. It should already work, but still generates more expensive code.

Finally, many new warnings were introduced and error messages improved.

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.

We especially thank all our open source community contributors:

Ali92hm, Aaron Colaço, Lefteris Karapetsas, Matthieu Caneill, Robert Edström and Suman

If you want to perform a source build, please only use solidity_0.4.17.tar.gz and not the zip provided by github directly.

Version 0.4.16

This release introduces several new features, some of which have to be
explicitly activated using pragma experimental <feature name>;.

We split the constant keyword for functions into pure (neither reads from nor writes to the state)
and view (does not modify the state). They are not enforced yet, but will most likely make use
of the the new STATIC_CALL feature after Metropolis.

Furthermore, the ABI encoder was re-implemented in a much cleaner way using our new intermediate language. It can encode arbitrarily nested arrays and will also be able to encode structs starting from the next release. Please try it out using pragma experimental ABIEncoderV2; and check if you have any issues with the encoder. It currently generates larger code than the old encoder, but we hope to fix that soon.

Finally, solc now include experimental support for automated overflow and assertion checking at compile-time using the SMT solver Z3. It is active if you use pragma experimental SMTChecker; and if solc was compiled with Z3 support. The latter is currently only the case for the PPA builds (or if you build from source and have libz3-dev in your system), but we also have a solution in the pipeline that will make it work for solc-js (and thus remix).

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.

We especially thank all our open source community contributors:

Chim Kan, Federico Bond, feliam, gubatron, Isaac Ibiapina, James Ray, Joshua Hannan, Lea Arias, Nick Savers, Stu West, Vladislav Ankudinov and Zhen Zhang

If you want to perform a source build, please only use solidity_0.4.16.tar.gz and not the zip provided by github directly.

Version 0.4.15

This is mainly a bugfix release that corrects a problem with the return value of the low-level delegatecall function and removes some invalid warning messages.

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.

We especially thank all our open source community contributors:

Leo Arias, Adrián Calvo and SaadSurya

If you want to perform a source build, please only use solidity_0.4.15.tar.gz and not the zip provided by github directly.