diff --git a/src/test/java/com/android/tools/r8/kotlin/AbstractR8KotlinTestBase.java b/src/test/java/com/android/tools/r8/kotlin/AbstractR8KotlinTestBase.java
index b3820dd..85f2eb5 100644
--- a/src/test/java/com/android/tools/r8/kotlin/AbstractR8KotlinTestBase.java
+++ b/src/test/java/com/android/tools/r8/kotlin/AbstractR8KotlinTestBase.java
@@ -16,8 +16,11 @@
 import com.android.tools.r8.ToolHelper.KotlinTargetVersion;
 import com.android.tools.r8.graph.Code;
 import com.android.tools.r8.graph.DexCode;
+import com.android.tools.r8.jasmin.JasminBuilder;
+import com.android.tools.r8.jasmin.JasminBuilder.ClassBuilder;
 import com.android.tools.r8.naming.MemberNaming.MethodSignature;
 import com.android.tools.r8.utils.AndroidApp;
+import com.android.tools.r8.utils.DescriptorUtils;
 import com.android.tools.r8.utils.DexInspector;
 import com.android.tools.r8.utils.DexInspector.ClassSubject;
 import com.android.tools.r8.utils.DexInspector.FieldSubject;
@@ -40,6 +43,10 @@
 @RunWith(Parameterized.class)
 public abstract class AbstractR8KotlinTestBase extends TestBase {
 
+  // This is the name of the Jasmin-generated class which contains the "main" method which will
+  // invoke the tested method.
+  private static final String JASMIN_MAIN_CLASS = "TestMain";
+
   @Parameters(name = "{0}_{1}")
   public static Collection<Object[]> data() {
     ImmutableList.Builder<Object[]> builder = new ImmutableList.Builder<>();
@@ -225,4 +232,26 @@
 
     void inspectApp(AndroidApp androidApp) throws Exception;
   }
+
+  /**
+   * Generates a "main" class which invokes the given static method (which has no argument and
+   * return void type). This new class is then added to the test classpath.
+   *
+   * @param methodClass the class of the static method to invoke
+   * @param methodName the name of the static method to invoke
+   * @return the name of the generated class
+   */
+  protected String addMainToClasspath(String methodClass, String methodName) throws Exception {
+    JasminBuilder builder = new JasminBuilder();
+    ClassBuilder mainClassBuilder =
+        builder.addClass(DescriptorUtils.getBinaryNameFromJavaType(JASMIN_MAIN_CLASS));
+    mainClassBuilder.addMainMethod(
+        "invokestatic " + methodClass + "/" + methodName + "()V",
+        "return"
+    );
+
+    Path output = writeToZip(builder);
+    addExtraClasspath(output);
+    return JASMIN_MAIN_CLASS;
+  }
 }
diff --git a/src/test/java/com/android/tools/r8/kotlin/KotlinCompanionClass.java b/src/test/java/com/android/tools/r8/kotlin/KotlinCompanionClass.java
new file mode 100644
index 0000000..bf36dde
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/kotlin/KotlinCompanionClass.java
@@ -0,0 +1,29 @@
+// Copyright (c) 2018, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.kotlin;
+
+/**
+ * Represents the definition of a Kotlin companion class.
+ *
+ * <p>See https://kotlinlang.org/docs/reference/object-declarations.html#companion-objects</p>
+ */
+public class KotlinCompanionClass extends KotlinClass {
+
+  private final String outerClassName;
+
+  public KotlinCompanionClass(String outerClassName) {
+    super(outerClassName + "$Companion");
+    this.outerClassName = outerClassName;
+  }
+
+  @Override
+  public KotlinCompanionClass addProperty(String name, String type, Visibility visibility) {
+    return (KotlinCompanionClass) super.addProperty(name, type, visibility);
+  }
+
+  public String getOuterClassName() {
+    return outerClassName;
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/kotlin/R8KotlinPropertiesTest.java b/src/test/java/com/android/tools/r8/kotlin/R8KotlinPropertiesTest.java
index c9e1298..499cc2f 100644
--- a/src/test/java/com/android/tools/r8/kotlin/R8KotlinPropertiesTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/R8KotlinPropertiesTest.java
@@ -6,15 +6,12 @@
 
 import static org.junit.Assert.assertTrue;
 
-import com.android.tools.r8.jasmin.JasminBuilder;
-import com.android.tools.r8.jasmin.JasminBuilder.ClassBuilder;
 import com.android.tools.r8.kotlin.KotlinClass.Visibility;
+import com.android.tools.r8.naming.MemberNaming;
 import com.android.tools.r8.naming.MemberNaming.MethodSignature;
-import com.android.tools.r8.utils.DescriptorUtils;
 import com.android.tools.r8.utils.DexInspector;
 import com.android.tools.r8.utils.DexInspector.ClassSubject;
 import com.android.tools.r8.utils.DexInspector.FieldSubject;
-import java.nio.file.Path;
 import org.junit.Test;
 
 public class R8KotlinPropertiesTest extends AbstractR8KotlinTestBase {
@@ -23,10 +20,6 @@
 
   private static final String JAVA_LANG_STRING = "java.lang.String";
 
-  // This is the name of the Jasmin-generated class which contains the "main" method which will
-  // invoke the tested method.
-  private static final String JASMIN_MAIN_CLASS = "properties.TestMain";
-
   private static final KotlinClass MUTABLE_PROPERTY_CLASS =
       new KotlinClass("properties.MutableProperty")
           .addProperty("privateProp", JAVA_LANG_STRING, Visibility.PRIVATE)
@@ -47,10 +40,28 @@
           .addProperty("internalLateInitProp", JAVA_LANG_STRING, Visibility.INTERNAL)
           .addProperty("publicLateInitProp", JAVA_LANG_STRING, Visibility.PUBLIC);
 
+  private static final KotlinCompanionClass COMPANION_PROPERTY_CLASS =
+      new KotlinCompanionClass("properties.CompanionProperties")
+          .addProperty("privateProp", JAVA_LANG_STRING, Visibility.PRIVATE)
+          .addProperty("protectedProp", JAVA_LANG_STRING, Visibility.PROTECTED)
+          .addProperty("internalProp", JAVA_LANG_STRING, Visibility.INTERNAL)
+          .addProperty("publicProp", JAVA_LANG_STRING, Visibility.PUBLIC)
+          .addProperty("primitiveProp", "int", Visibility.PUBLIC)
+          .addProperty("privateLateInitProp", JAVA_LANG_STRING, Visibility.PRIVATE)
+          .addProperty("internalLateInitProp", JAVA_LANG_STRING, Visibility.INTERNAL)
+          .addProperty("publicLateInitProp", JAVA_LANG_STRING, Visibility.PUBLIC);
+
+  private static final KotlinCompanionClass COMPANION_LATE_INIT_PROPERTY_CLASS =
+      new KotlinCompanionClass("properties.CompanionLateInitProperties")
+          .addProperty("privateLateInitProp", JAVA_LANG_STRING, Visibility.PRIVATE)
+          .addProperty("internalLateInitProp", JAVA_LANG_STRING, Visibility.INTERNAL)
+          .addProperty("publicLateInitProp", JAVA_LANG_STRING, Visibility.PUBLIC);
+
   @Test
   public void testMutableProperty_getterAndSetterAreRemoveIfNotUsed() throws Exception {
-    addMainToClasspath("properties/MutablePropertyKt", "mutableProperty_noUseOfProperties");
-    runTest(PACKAGE_NAME, JASMIN_MAIN_CLASS, (app) -> {
+    String mainClass = addMainToClasspath("properties/MutablePropertyKt",
+        "mutableProperty_noUseOfProperties");
+    runTest(PACKAGE_NAME, mainClass, (app) -> {
       DexInspector dexInspector = new DexInspector(app);
       ClassSubject classSubject = checkClassExists(dexInspector,
           MUTABLE_PROPERTY_CLASS.getClassName());
@@ -65,8 +76,9 @@
 
   @Test
   public void testMutableProperty_privateIsAlwaysInlined() throws Exception {
-    addMainToClasspath("properties/MutablePropertyKt", "mutableProperty_usePrivateProp");
-    runTest(PACKAGE_NAME, JASMIN_MAIN_CLASS, (app) -> {
+    String mainClass = addMainToClasspath("properties/MutablePropertyKt",
+        "mutableProperty_usePrivateProp");
+    runTest(PACKAGE_NAME, mainClass, (app) -> {
       DexInspector dexInspector = new DexInspector(app);
       ClassSubject classSubject = checkClassExists(dexInspector,
           MUTABLE_PROPERTY_CLASS.getClassName());
@@ -86,8 +98,9 @@
 
   @Test
   public void testMutableProperty_protectedIsAlwaysInlined() throws Exception {
-    addMainToClasspath("properties/MutablePropertyKt", "mutableProperty_useProtectedProp");
-    runTest(PACKAGE_NAME, JASMIN_MAIN_CLASS, (app) -> {
+    String mainClass = addMainToClasspath("properties/MutablePropertyKt",
+        "mutableProperty_useProtectedProp");
+    runTest(PACKAGE_NAME, mainClass, (app) -> {
       DexInspector dexInspector = new DexInspector(app);
       ClassSubject classSubject = checkClassExists(dexInspector,
           MUTABLE_PROPERTY_CLASS.getClassName());
@@ -108,8 +121,9 @@
 
   @Test
   public void testMutableProperty_internalIsAlwaysInlined() throws Exception {
-    addMainToClasspath("properties/MutablePropertyKt", "mutableProperty_useInternalProp");
-    runTest(PACKAGE_NAME, JASMIN_MAIN_CLASS, (app) -> {
+    String mainClass = addMainToClasspath("properties/MutablePropertyKt",
+        "mutableProperty_useInternalProp");
+    runTest(PACKAGE_NAME, mainClass, (app) -> {
       DexInspector dexInspector = new DexInspector(app);
       ClassSubject classSubject = checkClassExists(dexInspector,
           MUTABLE_PROPERTY_CLASS.getClassName());
@@ -130,8 +144,9 @@
 
   @Test
   public void testMutableProperty_publicIsAlwaysInlined() throws Exception {
-    addMainToClasspath("properties/MutablePropertyKt", "mutableProperty_usePublicProp");
-    runTest(PACKAGE_NAME, JASMIN_MAIN_CLASS, (app) -> {
+    String mainClass = addMainToClasspath("properties/MutablePropertyKt",
+        "mutableProperty_usePublicProp");
+    runTest(PACKAGE_NAME, mainClass, (app) -> {
       DexInspector dexInspector = new DexInspector(app);
       ClassSubject classSubject = checkClassExists(dexInspector,
           MUTABLE_PROPERTY_CLASS.getClassName());
@@ -152,8 +167,9 @@
 
   @Test
   public void testMutableProperty_primitivePropertyIsAlwaysInlined() throws Exception {
-    addMainToClasspath("properties/MutablePropertyKt", "mutableProperty_usePrimitiveProp");
-    runTest(PACKAGE_NAME, JASMIN_MAIN_CLASS, (app) -> {
+    String mainClass = addMainToClasspath("properties/MutablePropertyKt",
+        "mutableProperty_usePrimitiveProp");
+    runTest(PACKAGE_NAME, mainClass, (app) -> {
       DexInspector dexInspector = new DexInspector(app);
       ClassSubject classSubject = checkClassExists(dexInspector,
           MUTABLE_PROPERTY_CLASS.getClassName());
@@ -176,8 +192,9 @@
 
   @Test
   public void testLateInitProperty_getterAndSetterAreRemoveIfNotUsed() throws Exception {
-    addMainToClasspath("properties/LateInitPropertyKt", "lateInitProperty_noUseOfProperties");
-    runTest(PACKAGE_NAME, JASMIN_MAIN_CLASS, (app) -> {
+    String mainClass = addMainToClasspath("properties/LateInitPropertyKt",
+        "lateInitProperty_noUseOfProperties");
+    runTest(PACKAGE_NAME, mainClass, (app) -> {
       DexInspector dexInspector = new DexInspector(app);
       ClassSubject classSubject = checkClassExists(dexInspector,
           LATE_INIT_PROPERTY_CLASS.getClassName());
@@ -192,8 +209,9 @@
 
   @Test
   public void testLateInitProperty_privateIsAlwaysInlined() throws Exception {
-    addMainToClasspath("properties/LateInitPropertyKt", "lateInitProperty_usePrivateLateInitProp");
-    runTest(PACKAGE_NAME, JASMIN_MAIN_CLASS, (app) -> {
+    String mainClass = addMainToClasspath(
+        "properties/LateInitPropertyKt", "lateInitProperty_usePrivateLateInitProp");
+    runTest(PACKAGE_NAME, mainClass, (app) -> {
       DexInspector dexInspector = new DexInspector(app);
       ClassSubject classSubject = checkClassExists(dexInspector,
           LATE_INIT_PROPERTY_CLASS.getClassName());
@@ -214,9 +232,9 @@
 
   @Test
   public void testLateInitProperty_protectedIsAlwaysInlined() throws Exception {
-    addMainToClasspath("properties/LateInitPropertyKt",
+    String mainClass = addMainToClasspath("properties/LateInitPropertyKt",
         "lateInitProperty_useProtectedLateInitProp");
-    runTest(PACKAGE_NAME, JASMIN_MAIN_CLASS, (app) -> {
+    runTest(PACKAGE_NAME, mainClass, (app) -> {
       DexInspector dexInspector = new DexInspector(app);
       ClassSubject classSubject = checkClassExists(dexInspector,
           LATE_INIT_PROPERTY_CLASS.getClassName());
@@ -235,8 +253,9 @@
 
   @Test
   public void testLateInitProperty_internalIsAlwaysInlined() throws Exception {
-    addMainToClasspath("properties/LateInitPropertyKt", "lateInitProperty_useInternalLateInitProp");
-    runTest(PACKAGE_NAME, JASMIN_MAIN_CLASS, (app) -> {
+    String mainClass = addMainToClasspath(
+        "properties/LateInitPropertyKt", "lateInitProperty_useInternalLateInitProp");
+    runTest(PACKAGE_NAME, mainClass, (app) -> {
       DexInspector dexInspector = new DexInspector(app);
       ClassSubject classSubject = checkClassExists(dexInspector,
           LATE_INIT_PROPERTY_CLASS.getClassName());
@@ -253,8 +272,9 @@
 
   @Test
   public void testLateInitProperty_publicIsAlwaysInlined() throws Exception {
-    addMainToClasspath("properties/LateInitPropertyKt", "lateInitProperty_usePublicLateInitProp");
-    runTest(PACKAGE_NAME, JASMIN_MAIN_CLASS, (app) -> {
+    String mainClass = addMainToClasspath(
+        "properties/LateInitPropertyKt", "lateInitProperty_usePublicLateInitProp");
+    runTest(PACKAGE_NAME, mainClass, (app) -> {
       DexInspector dexInspector = new DexInspector(app);
       ClassSubject classSubject = checkClassExists(dexInspector,
           LATE_INIT_PROPERTY_CLASS.getClassName());
@@ -271,8 +291,9 @@
 
   @Test
   public void testUserDefinedProperty_getterAndSetterAreRemoveIfNotUsed() throws Exception {
-    addMainToClasspath("properties/UserDefinedPropertyKt", "userDefinedProperty_noUseOfProperties");
-    runTest(PACKAGE_NAME, JASMIN_MAIN_CLASS, (app) -> {
+    String mainClass = addMainToClasspath(
+        "properties/UserDefinedPropertyKt", "userDefinedProperty_noUseOfProperties");
+    runTest(PACKAGE_NAME, mainClass, (app) -> {
       DexInspector dexInspector = new DexInspector(app);
       ClassSubject classSubject = checkClassExists(dexInspector,
           USER_DEFINED_PROPERTY_CLASS.getClassName());
@@ -287,8 +308,9 @@
 
   @Test
   public void testUserDefinedProperty_publicIsAlwaysInlined() throws Exception {
-    addMainToClasspath("properties/UserDefinedPropertyKt", "userDefinedProperty_useProperties");
-    runTest(PACKAGE_NAME, JASMIN_MAIN_CLASS, (app) -> {
+    String mainClass = addMainToClasspath(
+        "properties/UserDefinedPropertyKt", "userDefinedProperty_useProperties");
+    runTest(PACKAGE_NAME, mainClass, (app) -> {
       DexInspector dexInspector = new DexInspector(app);
       ClassSubject classSubject = checkClassExists(dexInspector,
           USER_DEFINED_PROPERTY_CLASS.getClassName());
@@ -310,20 +332,209 @@
     });
   }
 
-  /**
-   * Generates a "main" class which invokes the given static method on the given klass. This new
-   * class is then added to the test classpath.
-   */
-  private void addMainToClasspath(String klass, String method) throws Exception {
-    JasminBuilder builder = new JasminBuilder();
-    ClassBuilder mainClassBuilder =
-        builder.addClass(DescriptorUtils.getBinaryNameFromJavaType(JASMIN_MAIN_CLASS));
-    mainClassBuilder.addMainMethod(
-        "invokestatic " + klass + "/" + method + "()V",
-        "return"
-    );
+  @Test
+  public void testCompanionProperty_primitivePropertyCannotBeInlined() throws Exception {
+    String mainClass = addMainToClasspath(
+        "properties.CompanionPropertiesKt", "companionProperties_usePrimitiveProp");
+    runTest(PACKAGE_NAME, mainClass, (app) -> {
+      DexInspector dexInspector = new DexInspector(app);
+      ClassSubject outerClass = checkClassExists(dexInspector,
+          "properties.CompanionProperties");
+      ClassSubject companionClass = checkClassExists(dexInspector,
+          COMPANION_PROPERTY_CLASS.getClassName());
+      String propertyName = "primitiveProp";
+      FieldSubject fieldSubject = checkFieldIsPresent(outerClass, "int", propertyName);
+      assertTrue(fieldSubject.getField().accessFlags.isStatic());
 
-    Path output = writeToZip(builder);
-    addExtraClasspath(output);
+      MemberNaming.MethodSignature getter = COMPANION_PROPERTY_CLASS
+          .getGetterForProperty(propertyName);
+      MemberNaming.MethodSignature setter = COMPANION_PROPERTY_CLASS
+          .getSetterForProperty(propertyName);
+
+      // Getter and setter cannot be inlined because we don't know if null check semantic is
+      // preserved.
+      checkMethodIsPresent(companionClass, getter);
+      checkMethodIsPresent(companionClass, setter);
+      if (allowAccessModification) {
+        assertTrue(fieldSubject.getField().accessFlags.isPublic());
+      } else {
+        assertTrue(fieldSubject.getField().accessFlags.isPrivate());
+      }
+    });
+  }
+
+  @Test
+  public void testCompanionProperty_privatePropertyIsAlwaysInlined() throws Exception {
+    String mainClass = addMainToClasspath(
+        "properties.CompanionPropertiesKt", "companionProperties_usePrivateProp");
+    runTest(PACKAGE_NAME, mainClass, (app) -> {
+      DexInspector dexInspector = new DexInspector(app);
+      ClassSubject outerClass = checkClassExists(dexInspector,
+          "properties.CompanionProperties");
+      ClassSubject companionClass = checkClassExists(dexInspector,
+          COMPANION_PROPERTY_CLASS.getClassName());
+      String propertyName = "privateProp";
+      FieldSubject fieldSubject = checkFieldIsPresent(outerClass, JAVA_LANG_STRING, propertyName);
+      assertTrue(fieldSubject.getField().accessFlags.isStatic());
+
+      MemberNaming.MethodSignature getter = COMPANION_PROPERTY_CLASS
+          .getGetterForProperty(propertyName);
+      MemberNaming.MethodSignature setter = COMPANION_PROPERTY_CLASS
+          .getSetterForProperty(propertyName);
+
+      // Because the getter/setter are private, they can only be called from another method in the
+      // class. If this is an instance method, they will be called on 'this' which is known to be
+      // non-null, thus the getter/setter can be inlined if their code is small enough.
+      // Because the backing field is private, they will call into an accessor (static) method. If
+      // access relaxation is enabled, this accessor can be removed.
+      checkMethodIsAbsent(companionClass, getter);
+      checkMethodIsAbsent(companionClass, setter);
+      if (allowAccessModification) {
+        assertTrue(fieldSubject.getField().accessFlags.isPublic());
+      } else {
+        assertTrue(fieldSubject.getField().accessFlags.isPrivate());
+      }
+    });
+  }
+
+  @Test
+  public void testCompanionProperty_internalPropertyCannotBeInlined() throws Exception {
+    String mainClass = addMainToClasspath(
+        "properties.CompanionPropertiesKt", "companionProperties_useInternalProp");
+    runTest(PACKAGE_NAME, mainClass, (app) -> {
+      DexInspector dexInspector = new DexInspector(app);
+      ClassSubject outerClass = checkClassExists(dexInspector,
+          "properties.CompanionProperties");
+      ClassSubject companionClass = checkClassExists(dexInspector,
+          COMPANION_PROPERTY_CLASS.getClassName());
+      String propertyName = "internalProp";
+      FieldSubject fieldSubject = checkFieldIsPresent(outerClass, JAVA_LANG_STRING, propertyName);
+      assertTrue(fieldSubject.getField().accessFlags.isStatic());
+
+      MemberNaming.MethodSignature getter = COMPANION_PROPERTY_CLASS
+          .getGetterForProperty(propertyName);
+      MemberNaming.MethodSignature setter = COMPANION_PROPERTY_CLASS
+          .getSetterForProperty(propertyName);
+
+      // Getter and setter cannot be inlined because we don't know if null check semantic is
+      // preserved.
+      checkMethodIsPresent(companionClass, getter);
+      checkMethodIsPresent(companionClass, setter);
+      if (allowAccessModification) {
+        assertTrue(fieldSubject.getField().accessFlags.isPublic());
+      } else {
+        assertTrue(fieldSubject.getField().accessFlags.isPrivate());
+      }
+    });
+  }
+
+  @Test
+  public void testCompanionProperty_publicPropertyCannotBeInlined() throws Exception {
+    String mainClass = addMainToClasspath(
+        "properties.CompanionPropertiesKt", "companionProperties_usePublicProp");
+    runTest(PACKAGE_NAME, mainClass, (app) -> {
+      DexInspector dexInspector = new DexInspector(app);
+      ClassSubject outerClass = checkClassExists(dexInspector,
+          "properties.CompanionProperties");
+      ClassSubject companionClass = checkClassExists(dexInspector,
+          COMPANION_PROPERTY_CLASS.getClassName());
+      String propertyName = "publicProp";
+      FieldSubject fieldSubject = checkFieldIsPresent(outerClass, JAVA_LANG_STRING, propertyName);
+      assertTrue(fieldSubject.getField().accessFlags.isStatic());
+
+      MemberNaming.MethodSignature getter = COMPANION_PROPERTY_CLASS
+          .getGetterForProperty(propertyName);
+      MemberNaming.MethodSignature setter = COMPANION_PROPERTY_CLASS
+          .getSetterForProperty(propertyName);
+
+      // Getter and setter cannot be inlined because we don't know if null check semantic is
+      // preserved.
+      checkMethodIsPresent(companionClass, getter);
+      checkMethodIsPresent(companionClass, setter);
+      if (allowAccessModification) {
+        assertTrue(fieldSubject.getField().accessFlags.isPublic());
+      } else {
+        assertTrue(fieldSubject.getField().accessFlags.isPrivate());
+      }
+    });
+  }
+
+  @Test
+  public void testCompanionProperty_privateLateInitPropertyIsAlwaysInlined() throws Exception {
+    final KotlinCompanionClass testedClass = COMPANION_LATE_INIT_PROPERTY_CLASS;
+    String mainClass = addMainToClasspath("properties.CompanionLateInitPropertiesKt",
+        "companionLateInitProperties_usePrivateLateInitProp");
+    runTest(PACKAGE_NAME, mainClass, (app) -> {
+      DexInspector dexInspector = new DexInspector(app);
+      ClassSubject outerClass = checkClassExists(dexInspector, testedClass.getOuterClassName());
+      ClassSubject companionClass = checkClassExists(dexInspector, testedClass.getClassName());
+      String propertyName = "privateLateInitProp";
+      FieldSubject fieldSubject = checkFieldIsPresent(outerClass, JAVA_LANG_STRING, propertyName);
+      assertTrue(fieldSubject.getField().accessFlags.isStatic());
+
+      MemberNaming.MethodSignature getter = testedClass.getGetterForProperty(propertyName);
+      MemberNaming.MethodSignature setter = testedClass.getSetterForProperty(propertyName);
+
+      // Because the getter/setter are private, they can only be called from another method in the
+      // class. If this is an instance method, they will be called on 'this' which is known to be
+      // non-null, thus the getter/setter can be inlined if their code is small enough.
+      // Because the backing field is private, they will call into an accessor (static) method. If
+      // access relaxation is enabled, this accessor can be removed.
+      checkMethodIsAbsent(companionClass, getter);
+      checkMethodIsAbsent(companionClass, setter);
+      if (allowAccessModification) {
+        assertTrue(fieldSubject.getField().accessFlags.isPublic());
+      } else {
+        assertTrue(fieldSubject.getField().accessFlags.isPrivate());
+      }
+    });
+  }
+
+  @Test
+  public void testCompanionProperty_internalLateInitPropertyCannotBeInlined() throws Exception {
+    final KotlinCompanionClass testedClass = COMPANION_LATE_INIT_PROPERTY_CLASS;
+    String mainClass = addMainToClasspath("properties.CompanionLateInitPropertiesKt",
+        "companionLateInitProperties_useInternalLateInitProp");
+    runTest(PACKAGE_NAME, mainClass, (app) -> {
+      DexInspector dexInspector = new DexInspector(app);
+      ClassSubject outerClass = checkClassExists(dexInspector, testedClass.getOuterClassName());
+      ClassSubject companionClass = checkClassExists(dexInspector, testedClass.getClassName());
+      String propertyName = "internalLateInitProp";
+      FieldSubject fieldSubject = checkFieldIsPresent(outerClass, JAVA_LANG_STRING, propertyName);
+      assertTrue(fieldSubject.getField().accessFlags.isStatic());
+
+      MemberNaming.MethodSignature getter = testedClass.getGetterForProperty(propertyName);
+      MemberNaming.MethodSignature setter = testedClass.getSetterForProperty(propertyName);
+
+      // Getter and setter cannot be inlined because we don't know if null check semantic is
+      // preserved.
+      checkMethodIsPresent(companionClass, getter);
+      checkMethodIsPresent(companionClass, setter);
+      assertTrue(fieldSubject.getField().accessFlags.isPublic());
+    });
+  }
+
+  @Test
+  public void testCompanionProperty_publicLateInitPropertyCannotBeInlined() throws Exception {
+    final KotlinCompanionClass testedClass = COMPANION_LATE_INIT_PROPERTY_CLASS;
+    String mainClass = addMainToClasspath("properties.CompanionLateInitPropertiesKt",
+        "companionLateInitProperties_usePublicLateInitProp");
+    runTest(PACKAGE_NAME, mainClass, (app) -> {
+      DexInspector dexInspector = new DexInspector(app);
+      ClassSubject outerClass = checkClassExists(dexInspector, testedClass.getOuterClassName());
+      ClassSubject companionClass = checkClassExists(dexInspector, testedClass.getClassName());
+      String propertyName = "publicLateInitProp";
+      FieldSubject fieldSubject = checkFieldIsPresent(outerClass, JAVA_LANG_STRING, propertyName);
+      assertTrue(fieldSubject.getField().accessFlags.isStatic());
+
+      MemberNaming.MethodSignature getter = testedClass.getGetterForProperty(propertyName);
+      MemberNaming.MethodSignature setter = testedClass.getSetterForProperty(propertyName);
+
+      // Getter and setter cannot be inlined because we don't know if null check semantic is
+      // preserved.
+      checkMethodIsPresent(companionClass, getter);
+      checkMethodIsPresent(companionClass, setter);
+      assertTrue(fieldSubject.getField().accessFlags.isPublic());
+    });
   }
 }
diff --git a/src/test/kotlinR8TestResources/properties/CompanionLateInitProperties.kt b/src/test/kotlinR8TestResources/properties/CompanionLateInitProperties.kt
new file mode 100644
index 0000000..d3db0f4
--- /dev/null
+++ b/src/test/kotlinR8TestResources/properties/CompanionLateInitProperties.kt
@@ -0,0 +1,41 @@
+// Copyright (c) 2018, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package properties
+
+class CompanionLateInitProperties {
+    companion object {
+        private lateinit var privateLateInitProp: String
+        internal lateinit var internalLateInitProp: String
+        public lateinit var publicLateInitProp: String
+
+        fun callSetterPrivateProp(v: String) {
+            privateLateInitProp = v
+        }
+
+        fun callGetterPrivateProp(): String {
+            return privateLateInitProp
+        }
+    }
+}
+
+fun companionLateInitProperties_noUseOfProperties() {
+    CompanionLateInitProperties()
+    println("DONE")
+}
+
+fun companionLateInitProperties_usePrivateLateInitProp() {
+    CompanionLateInitProperties.callSetterPrivateProp("foo")
+    println(CompanionLateInitProperties.callGetterPrivateProp())
+}
+
+fun companionLateInitProperties_useInternalLateInitProp() {
+    CompanionLateInitProperties.internalLateInitProp = "foo"
+    println(CompanionLateInitProperties.internalLateInitProp)
+}
+
+fun companionLateInitProperties_usePublicLateInitProp() {
+    CompanionLateInitProperties.publicLateInitProp = "foo"
+    println(CompanionLateInitProperties.publicLateInitProp)
+}
diff --git a/src/test/kotlinR8TestResources/properties/CompanionProperties.kt b/src/test/kotlinR8TestResources/properties/CompanionProperties.kt
new file mode 100644
index 0000000..d0e3082
--- /dev/null
+++ b/src/test/kotlinR8TestResources/properties/CompanionProperties.kt
@@ -0,0 +1,48 @@
+// Copyright (c) 2018, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package properties
+
+class CompanionProperties {
+    companion object {
+        private var privateProp: String = "privateProp"
+        internal var internalProp: String = "internalProp"
+        public var publicProp: String = "publicProp"
+
+        public var primitiveProp: Int = Int.MAX_VALUE
+
+        fun callSetterPrivateProp(v: String) {
+            privateProp = v
+        }
+
+        fun callGetterPrivateProp(): String {
+            return privateProp
+        }
+    }
+}
+
+fun companionProperties_noUseOfProperties() {
+    CompanionProperties()
+    println("DONE")
+}
+
+fun companionProperties_usePrivateProp() {
+    CompanionProperties.callSetterPrivateProp("foo")
+    println(CompanionProperties.callGetterPrivateProp())
+}
+
+fun companionProperties_useInternalProp() {
+    CompanionProperties.internalProp = "foo"
+    println(CompanionProperties.internalProp)
+}
+
+fun companionProperties_usePublicProp() {
+    CompanionProperties.publicProp = "foo"
+    println(CompanionProperties.publicProp)
+}
+
+fun companionProperties_usePrimitiveProp() {
+    CompanionProperties.primitiveProp = Int.MIN_VALUE
+    println(CompanionProperties.primitiveProp)
+}