--- old/src/java.base/share/classes/java/lang/Class.java	2019-05-31 15:05:50.604524748 -0400
+++ new/src/java.base/share/classes/java/lang/Class.java	2019-05-31 15:05:50.204522764 -0400
@@ -631,11 +631,6 @@
     public T newInstance()
         throws InstantiationException, IllegalAccessException
     {
-        if (this.isInlineClass()) {
-            throw new IllegalAccessException(
-                "cannot create new instance of an inline class " + this.getName());
-        }
-
         SecurityManager sm = System.getSecurityManager();
         if (sm != null) {
             checkMemberAccess(sm, Member.PUBLIC, Reflection.getCallerClass(), false);
--- old/src/java.base/share/classes/java/lang/reflect/Constructor.java	2019-05-31 15:05:51.828530817 -0400
+++ new/src/java.base/share/classes/java/lang/reflect/Constructor.java	2019-05-31 15:05:51.420528794 -0400
@@ -180,10 +180,6 @@
         AccessibleObject.checkPermission();
 
         if (flag) {
-            if (clazz.isInlineClass()) {
-                throw new InaccessibleObjectException(
-                    "Unable to make an inline class constructor \"" + this + "\" accessible");
-            }
             checkCanSetAccessible(Reflection.getCallerClass());
         }
         setAccessible0(flag);
@@ -482,10 +478,6 @@
         throws InstantiationException, IllegalAccessException,
                IllegalArgumentException, InvocationTargetException
     {
-        if (clazz.isInlineClass()) {
-            throw new IllegalAccessException(
-                "cannot create new instance of an inline class " + clazz.getName());
-        }
         Class<?> caller = override ? null : Reflection.getCallerClass();
         return newInstanceWithCaller(initargs, !override, caller);
     }
--- old/test/jdk/valhalla/valuetypes/Reflection.java	2019-05-31 15:05:53.012536689 -0400
+++ new/test/jdk/valhalla/valuetypes/Reflection.java	2019-05-31 15:05:52.612534705 -0400
@@ -29,8 +29,14 @@
  * @run main/othervm -XX:+EnableValhalla Reflection
  */
 
-import java.lang.reflect.*;
+import java.lang.reflect.Array;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Field;
+import java.lang.reflect.InaccessibleObjectException;
+import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
 import java.util.Arrays;
+import java.util.List;
 import java.util.stream.Collectors;
 
 public class Reflection {
@@ -47,10 +53,12 @@
         Reflection test = new Reflection(Point.class, "Point", o);
         test.newInstance();
         test.constructor();
+        test.constructors("public Point(int,int)", "Point()");
         test.accessFieldX(o.x);
         test.setAccessible();
         test.trySetAccessible();
         test.staticField();
+        test.initFactoryNotMethods();
     }
 
     static void testLineClass() throws Exception {
@@ -60,6 +68,8 @@
         test.checkField("public final Point Line.p2", "p2", Point.class);
         test.checkMethod("public Point Line.p1()",           "p1", Point.class);
         test.checkMethod("public Point Line.p2()",           "p2", Point.class);
+        test.initFactoryNotMethods();
+        test.constructors("Line()");
     }
 
     static void testNonFlattenValue() throws Exception {
@@ -69,6 +79,9 @@
         test.checkMethod("public Point NonFlattenValue.pointValue()", "pointValue", Point.class);
         test.checkMethod("public Point? NonFlattenValue.point()", "point", Point.class.asNullableType());
         test.checkMethod("public boolean NonFlattenValue.has(Point,Point?)", "has", boolean.class, Point.class, Point.class.asNullableType());
+        test.initFactoryNotMethods();
+        test.constructors("NonFlattenValue()");
+
     }
 
     /*
@@ -173,36 +186,43 @@
         } catch (IllegalAccessException e) {}
     }
 
+    @SuppressWarnings("deprecation")
     void newInstance() throws Exception {
-        try {
-            Object o = c.newInstance();
-            throw new RuntimeException("newInstance expected to be unsupported on inline class");
-        } catch (IllegalAccessException e) {}
+        Object o = c.newInstance();
+        assertEquals(o.getClass(), c);
     }
 
     void constructor() throws Exception {
-        try {
-            ctor.newInstance();
-            throw new RuntimeException("IllegalAccessException not thrown");
-        } catch (IllegalAccessException e) { }
+        Object o = ctor.newInstance();
+        assertEquals(o.getClass(), c);
+    }
+
+    // Check that the class has the expected Constructors
+    void constructors(String... expected) throws Exception {
+        Constructor<? extends Object>[] cons = c.getDeclaredConstructors();
+        List<String> declaredSig = Arrays.stream(cons).map( Constructor::toString).collect(Collectors.toList());
+        List<String> expectedSig = List.of(expected);
+        boolean ok = expectedSig.equals(declaredSig);
+        if (!ok) {
+            System.out.printf("expected: %s%n", expectedSig);
+            System.out.printf("declared: %s%n", declaredSig);
+            assertTrue(ok);
+        }
     }
 
     void setAccessible() throws Exception {
-        try {
-            ctor.setAccessible(true);
-            throw new RuntimeException("InaccessibleObjectException not thrown");
-        } catch (InaccessibleObjectException e) { e.printStackTrace(); }
+        ctor.setAccessible(true);
         Field field = c.getField("x");
         try {
             field.setAccessible(true);
             throw new RuntimeException("InaccessibleObjectException not thrown");
-        } catch (InaccessibleObjectException e) { e.printStackTrace(); }
+        } catch (InaccessibleObjectException e) {
+            System.out.println("as expected: " + e.toString());
+        }
     }
 
     void trySetAccessible() throws Exception {
-        if (ctor.trySetAccessible()) {
-            throw new RuntimeException("trySetAccessible should not succeed");
-        }
+        ctor.trySetAccessible();
         Field field = c.getField("x");
         if (field.trySetAccessible()) {
             throw new RuntimeException("trySetAccessible should not succeed");
@@ -231,6 +251,16 @@
         assertEquals(m.toString(), source);
     }
 
+    // Check that the class does not have a static method with the name <init>
+    void initFactoryNotMethods() throws Exception {
+        Method[] methods = c.getDeclaredMethods();
+        for (Method m : methods) {
+            if (Modifier.isStatic(m.getModifiers())) {
+                assertFalse(m.getName().equals("<init>"));
+            }
+        }
+    }
+
     static void assertEquals(Object o1, Object o2) {
         if (o1 == o2 || o1.equals(o2))
             return;