Solidity – Compile Error: Expected Primary Expression

Tl;dr: Get rid of the uint256.

The changes I had to make to get your code working are to:

• Define a contract User as your contract code refers to user in contract Landlord is user. I renamed user to User to keep with the case convention;
• Define a contract Tenant as your contract code refers to the statement Tenant person = Tenant(_tenantAddress);;
• Define a method setRent(uint256 _rent) in the contract Tenant as your contract code calls setRent(...) in the statement person.setRent(uint256 _rent);; and
• Remove the uint256 from your call to setRent(...).

Here's the code I modified to get your code to compile correctly:

pragma solidity ^0.4.0;

contract User {
}

contract Tenant {
    address tenant;
    uint256 rent;

    function Tenant(address _tenant) {
        tenant = _tenant;
    }

    function setRent(uint256 _rent) {
        rent = _rent;
    }
}

contract Landlord is User {
    string public landlordName;
    string public physicalAddress;

    function Landlord(
      string _name,
      string _physicalAddress) {
        landlordName = _name;
        physicalAddress = _physicalAddress;
    }

    function setRent(uint256 _rent, address _tenantAddress){
        Tenant person = Tenant(_tenantAddress);
        person.setRent(_rent);
    }
}    

Here's a screenshot of your modified code compiling in the Solidity realtime compiler and runtime:

You cannot convert a uint256 to bytes1 directly, but if you convert it to uint8 first it works:

reversed[i++] = bytes1(uint8(48 + remainder));

So the full code looks like this:

function uintToString(uint v) public pure returns (string memory) {
    uint maxlength = 100;
    bytes memory reversed = new bytes(maxlength);
    uint i = 0;
    while (v != 0) {
        uint remainder = v % 10;
        v = v / 10;
        reversed[i++] = bytes1(uint8(48 + remainder));
    }
    bytes memory s = new bytes(i); // i + 1 is inefficient
    for (uint j = 0; j < i; j++) {
        s[j] = reversed[i - j - 1]; // to avoid the off-by-one error
    }
    string memory str = string(s);  // memory isn't implicitly convertible to storage
    return str;
}