title: TypeError: No matching declaration found after variable lookup balanceOf[msg.sender] = totalSupply_
body: <p>So I am using a combination of Openzepplin solidity contracts to create a burnable token with a supply cap of 3million.
  I keep getting the above error on the last contract and I have no idea why. I have tried replacing balanceOf[msg.sender] with balances[msg.sender], totalSupply_ with totalSupply, and re-declaring the existence of a public uint256 in the local contract (despite the fact that it should be inherited.</p>
  
  <p>The following is my flattened contract with all dependencies (thanks for your help!):</p>
  
  <pre><code>pragma solidity ^0.4.24;
  
  // File: contracts\token\ERC20\ERC20.sol
  
  /**
   * @title ERC20 interface
   * @dev see https://github.com/ethereum/EIPs/issues/20
   */
  contract ERC20 {
    function totalSupply() public view returns (uint256);
  
    function balanceOf(address _who) public view returns (uint256);
  
    function allowance(address _owner, address _spender)
      public view returns (uint256);
  
    function transfer(address _to, uint256 _value) public returns (bool);
  
    function approve(address _spender, uint256 _value)
      public returns (bool);
  
    function transferFrom(address _from, address _to, uint256 _value)
      public returns (bool);
  
    event Transfer(
      address indexed from,
      address indexed to,
      uint256 value
    );
  
    event Approval(
      address indexed owner,
      address indexed spender,
      uint256 value
    );
  }
  
  // File: contracts\math\SafeMath.sol
  
  /**
   * @title SafeMath
   * @dev Math operations with safety checks that revert on error
   */
  library SafeMath {
  
    /**
    * @dev Multiplies two numbers, reverts on overflow.
    */
    function mul(uint256 _a, uint256 _b) internal pure returns (uint256) {
      // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
      // benefit is lost if 'b' is also tested.
      // See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
      if (_a == 0) {
        return 0;
      }
  
      uint256 c = _a * _b;
      require(c / _a == _b);
  
      return c;
    }
  
    /**
    * @dev Integer division of two numbers truncating the quotient, reverts on division by zero.
    */
    function div(uint256 _a, uint256 _b) internal pure returns (uint256) {
      require(_b &gt; 0); // Solidity only automatically asserts when dividing by 0
      uint256 c = _a / _b;
      // assert(_a == _b * c + _a % _b); // There is no case in which this doesn't hold
  
      return c;
    }
  
    /**
    * @dev Subtracts two numbers, reverts on overflow (i.e. if subtrahend is greater than minuend).
    */
    function sub(uint256 _a, uint256 _b) internal pure returns (uint256) {
      require(_b &lt;= _a);
      uint256 c = _a - _b;
  
      return c;
    }
  
    /**
    * @dev Adds two numbers, reverts on overflow.
    */
    function add(uint256 _a, uint256 _b) internal pure returns (uint256) {
      uint256 c = _a + _b;
      require(c &gt;= _a);
  
      return c;
    }
  
    /**
    * @dev Divides two numbers and returns the remainder (unsigned integer modulo),
    * reverts when dividing by zero.
    */
    function mod(uint256 a, uint256 b) internal pure returns (uint256) {
      require(b != 0);
      return a % b;
    }
  }
  
  // File: contracts\token\ERC20\StandardToken.sol
  
  /**
   * @title Standard ERC20 token
   *
   * @dev Implementation of the basic standard token.
   * https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20.md
   * Based on code by FirstBlood: https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
   */
  contract StandardToken is ERC20 {
    using SafeMath for uint256;
  
    mapping (address =&gt; uint256) private balances;
  
    mapping (address =&gt; mapping (address =&gt; uint256)) private allowed;
  
    uint256 public totalSupply_;
  
    /**
    * @dev Total number of tokens in existence
    */
    function totalSupply() public view returns (uint256) {
      return totalSupply_;
    }
  
    /**
    * @dev Gets the balance of the specified address.
    * @param _owner The address to query the the balance of.
    * @return An uint256 representing the amount owned by the passed address.
    */
    function balanceOf(address _owner) public view returns (uint256) {
      return balances[_owner];
    }
  
    /**
     * @dev Function to check the amount of tokens that an owner allowed to a spender.
     * @param _owner address The address which owns the funds.
     * @param _spender address The address which will spend the funds.
     * @return A uint256 specifying the amount of tokens still available for the spender.
     */
    function allowance(
      address _owner,
      address _spender
     )
      public
      view
      returns (uint256)
    {
      return allowed[_owner][_spender];
    }
  
    /**
    * @dev Transfer token for a specified address
    * @param _to The address to transfer to.
    * @param _value The amount to be transferred.
    */
    function transfer(address _to, uint256 _value) public returns (bool) {
      require(_value &lt;= balances[msg.sender]);
      require(_to != address(0));
  
      balances[msg.sender] = balances[msg.sender].sub(_value);
      balances[_to] = balances[_to].add(_value);
      emit Transfer(msg.sender, _to, _value);
      return true;
    }
  
    /**
     * @dev Approve the passed address to spend the specified amount of tokens on behalf of msg.sender.
     * Beware that changing an allowance with this method brings the risk that someone may use both the old
     * and the new allowance by unfortunate transaction ordering. One possible solution to mitigate this
     * race condition is to first reduce the spender's allowance to 0 and set the desired value afterwards:
     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
     * @param _spender The address which will spend the funds.
     * @param _value The amount of tokens to be spent.
     */
    function approve(address _spender, uint256 _value) public returns (bool) {
      allowed[msg.sender][_spender] = _value;
      emit Approval(msg.sender, _spender, _value);
      return true;
    }
  
    /**
     * @dev Transfer tokens from one address to another
     * @param _from address The address which you want to send tokens from
     * @param _to address The address which you want to transfer to
     * @param _value uint256 the amount of tokens to be transferred
     */
    function transferFrom(
      address _from,
      address _to,
      uint256 _value
    )
      public
      returns (bool)
    {
      require(_value &lt;= balances[_from]);
      require(_value &lt;= allowed[_from][msg.sender]);
      require(_to != address(0));
  
      balances[_from] = balances[_from].sub(_value);
      balances[_to] = balances[_to].add(_value);
      allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
      emit Transfer(_from, _to, _value);
      return true;
    }
  
    /**
     * @dev Increase the amount of tokens that an owner allowed to a spender.
     * approve should be called when allowed[_spender] == 0. To increment
     * allowed value is better to use this function to avoid 2 calls (and wait until
     * the first transaction is mined)
     * From MonolithDAO Token.sol
     * @param _spender The address which will spend the funds.
     * @param _addedValue The amount of tokens to increase the allowance by.
     */
    function increaseApproval(
      address _spender,
      uint256 _addedValue
    )
      public
      returns (bool)
    {
      allowed[msg.sender][_spender] = (
        allowed[msg.sender][_spender].add(_addedValue));
      emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
      return true;
    }
  
    /**
     * @dev Decrease the amount of tokens that an owner allowed to a spender.
     * approve should be called when allowed[_spender] == 0. To decrement
     * allowed value is better to use this function to avoid 2 calls (and wait until
     * the first transaction is mined)
     * From MonolithDAO Token.sol
     * @param _spender The address which will spend the funds.
     * @param _subtractedValue The amount of tokens to decrease the allowance by.
     */
    function decreaseApproval(
      address _spender,
      uint256 _subtractedValue
    )
      public
      returns (bool)
    {
      uint256 oldValue = allowed[msg.sender][_spender];
      if (_subtractedValue &gt;= oldValue) {
        allowed[msg.sender][_spender] = 0;
      } else {
        allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
      }
      emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
      return true;
    }
  
    /**
     * @dev Internal function that mints an amount of the token and assigns it to
     * an account. This encapsulates the modification of balances such that the
     * proper events are emitted.
     * @param _account The account that will receive the created tokens.
     * @param _amount The amount that will be created.
     */
    function _mint(address _account, uint256 _amount) internal {
      require(_account != 0);
      totalSupply_ = totalSupply_.add(_amount);
      balances[_account] = balances[_account].add(_amount);
      emit Transfer(address(0), _account, _amount);
    }
  
    /**
     * @dev Internal function that burns an amount of the token of a given
     * account.
     * @param _account The account whose tokens will be burnt.
     * @param _amount The amount that will be burnt.
     */
    function _burn(address _account, uint256 _amount) internal {
      require(_account != 0);
      require(balances[_account] &gt; _amount);
  
      totalSupply_ = totalSupply_.sub(_amount);
      balances[_account] = balances[_account].sub(_amount);
      emit Transfer(_account, address(0), _amount);
    }
  
    /**
     * @dev Internal function that burns an amount of the token of a given
     * account, deducting from the sender's allowance for said account. Uses the
     * internal _burn function.
     * @param _account The account whose tokens will be burnt.
     * @param _amount The amount that will be burnt.
     */
    function _burnFrom(address _account, uint256 _amount) internal {
      require(allowed[_account][msg.sender] &gt; _amount);
  
      // Should https://github.com/OpenZeppelin/zeppelin-solidity/issues/707 be accepted,
      // this function needs to emit an event with the updated approval.
      allowed[_account][msg.sender] = allowed[_account][msg.sender].sub(_amount);
      _burn(_account, _amount);
    }
  }
  
  // File: contracts\token\ERC20\BurnableToken.sol
  
  /**
   * @title Burnable Token
   * @dev Token that can be irreversibly burned (destroyed).
   */
  contract BurnableToken is StandardToken {
  
    event Burn(address indexed burner, uint256 value);
  
    /**
     * @dev Burns a specific amount of tokens.
     * @param _value The amount of token to be burned.
     */
    function burn(uint256 _value) public {
      _burn(msg.sender, _value);
    }
  
    /**
     * @dev Burns a specific amount of tokens from the target address and decrements allowance
     * @param _from address The address which you want to send tokens from
     * @param _value uint256 The amount of token to be burned
     */
    function burnFrom(address _from, uint256 _value) public {
      _burnFrom(_from, _value);
    }
  
    /**
     * @dev Overrides StandardToken._burn in order for burn and burnFrom to emit
     * an additional Burn event.
     */
    function _burn(address _who, uint256 _value) internal {
      super._burn(_who, _value);
      emit Burn(_who, _value);
    }
  }
  /**
   * @title KWATT_Token Token
   * @dev Token that can be irreversibly burned (destroyed).
   */
  contract KWATT_Token is BurnableToken {
      string public name = "Token";
      string public symbol = "TKN";
      uint8 public decimals = 18;
      uint public INITIAL_SUPPLY = 300000000;
  constructor() public {
    totalSupply_ = INITIAL_SUPPLY;
    balanceOf[msg.sender] = totalSupply_;
  }
  
  }
  </code></pre>